visual studio विजुअल स्टूडियो समाधान में कोड की रेखाओं की गणना कैसे करते हैं?




visual-studio code-metrics (20)

वीएस -2008 (ओपन सोर्स) के लिए अन्य सरल उपकरण: http://www.accendo.sk/Download/SourceStat.zip

क्या पूरे समाधान में कोड की रेखाओं की संख्या को खोजना संभव है? मैंने MZ-Tools बारे में सुना है, लेकिन क्या ओपन सोर्स बराबर है?


विजुअल स्टूडियो टीम सिस्टम 2008 में आप मेनू से विश्लेषण कर सकते हैं -> 'समाधान के लिए कोड मेट्रिक्स की गणना करें' और यह आपको अपने पूरे समाधान की लाइन गिनती देगा (अन्य चीजों के साथ जी )



आप विजुअल स्टूडियो कोड मेट्रिक्स पावरटूल 10.0 का उपयोग कर सकते हैं। यह एक कमांड लाइन उपयोगिता है जो आपके लिए प्रबंधित कोड (कोड की रेखाओं सहित) पर कुछ मीट्रिक की गणना करती है। आप एक वीएस 2010 प्लगइन प्राप्त कर सकते हैं जो टूल को विजुअल स्टूडियो में लाता है , और इसे मेनू आइटम का चयन करने और "समाधान का विश्लेषण" पर क्लिक करने के रूप में त्वरित बनाता है।


आप इसका उपयोग कर सकते हैं:


Neptuner कोशिश करो। यह आपको लोके के अलावा रिक्त स्थान, टैब, टिप्पणियों की रेखा जैसी चीजें भी प्रदान करता है। http://neptuner.googlecode.com/files/neptuner_0_30_windows.zip


मेनू-> विश्लेषण -> विजुअल स्टूडियो 2010 अल्टीमेट में कोड मेट्रिक्स विकल्प की गणना करें।


मुझे इसके लिए powershell उपयोगी पाया गया है। मैं लोका को किसी भी तरह का फर्जी मेट्रिक मानता हूं, इसलिए मुझे विश्वास नहीं है कि औपचारिकता की आवश्यकता होनी चाहिए।

एक छोटे समाधान की निर्देशिका से:

PS C:\Path> (gci -include *.cs,*.xaml -recurse | select-string .).Count
8396
PS C:\Path>

यह सभी समाधान की .cs और .xaml फ़ाइलों में गैर-रिक्त रेखाओं की गणना करेगा। एक बड़ी परियोजना के लिए, मैंने अभी एक अलग एक्सटेंशन सूची का उपयोग किया है:

PS C:\Other> (gci -include *.cs,*.cpp,*.h,*.idl,*.asmx -recurse | select-string .).Count
909402
PS C:\Other>

एक एकल ऐप का उपयोग क्यों करें जब एक कमांड लाइन इसे करेगी? :)





यहां उन लोगों के लिए विजुअल स्टूडियो 2012/2013/2015 के लिए एक अपडेट है जो "ढूंढें" विकल्प (जो मुझे सबसे आसान लगता है) करना चाहते हैं: यह RegEx सभी सटीक परिणामों को देने के लिए कई बहिष्कारों के साथ सभी गैर-रिक्त रेखाएं पायेगा ।

"ढूँढें" बॉक्स में निम्न RegEx दर्ज करें। कृपया "नियमित अभिव्यक्तियों का उपयोग करें" विकल्प का चयन करना सुनिश्चित करें। अपनी जरूरतों के आधार पर खोज विकल्प को "वर्तमान परियोजना" या "संपूर्ण समाधान" में बदलें। अब "सभी खोजें" का चयन करें। खोज परिणाम विंडो के नीचे, आपको "मिलान रेखाएं" दिखाई देगी जो कोड गणना की रेखाएं हैं।

^(?!(\s*\*))(?!(\s*\-\-\>))(?!(\s*\<\!\-\-))(?!(\s*\n))(?!(\s*\*\/))(?!(\s*\/\*))(?!(\s*\/\/\/))(?!(\s*\/\/))(?!(\s*\}))(?!(\s*\{))(?!(\s(using))).*$

इस RegEx में निम्नलिखित आइटम शामिल नहीं हैं:

टिप्पणियाँ

// This is a comment

मल्टी-लाइन टिप्पणियां (मान लीजिए कि लाइनों को प्रत्येक पंक्ति के सामने * के साथ सही ढंग से टिप्पणी की जाती है)

/* I am a
* multi-line
* comment */

Intellisense के लिए एक्सएमएल

/// <summary>
/// I'm a class description for Intellisense
/// </summary>

एचटीएमएल टिप्पणियाँ:

<!-- I am a HTML Comment -->

कथन का प्रयोग करना:

using System;
using System.Web;

घुंघराले ब्रेसिज़ खोलना:

{

घुंघराले ब्रेसिज़ बंद करना:

}

नोट: ब्रेसिज़ के बीच कुछ भी खोज में शामिल किया जाएगा, लेकिन इस उदाहरण में कोड की केवल 4 पंक्तियों की गणना 18 वास्तविक गैर-खाली रेखाओं के बजाय होगी:

        public class Test
        {
            /// <summary>
            /// Do Stuff
            /// </summary>
            public Test()
            {
                TestMe();
            }
            public void TestMe()
            {
                //Do Stuff Here
                /* And
                 * Do
                 * Stuff
                 * Here */
            }
        }

मैंने इसे पिछले कुछ विकल्पों की तुलना में अधिक सटीक एलओसी गिनती देने के लिए बनाया है, और मुझे लगता है कि मैं साझा करूंगा। मालिकों को एलओसी गिनती पसंद है, इसलिए मैं थोड़ी देर के लिए इसके साथ अटक गया हूँ। मुझे आशा है कि कोई और यह सहायक पा सकता है, अगर आपको कोई प्रश्न है या इसे काम करने में मदद की ज़रूरत है तो मुझे बताएं।


वीएस -2010 और 2012 के बीच नियमित अभिव्यक्तियां बदल गई हैं, इसलिए नियमित रूप से नियमित अभिव्यक्ति समाधान अब काम नहीं करते हैं

(^(?!(\s*//.+)))+(^(?!(#.+)))+(^(?!(\s*\{.+)))+(^(?!(\s*\}.+)))+(^(?!(\s*\r?$)))+

उन सभी लाइनों को मिलेगा जो रिक्त नहीं हैं, केवल एक ही ब्रैकेट ('{' या '}' नहीं हैं) न कि सिर्फ # अंतर्निहित या अन्य प्रीप्रोसेसर।

Ctrl - shift - f का उपयोग करें और सुनिश्चित करें कि नियमित अभिव्यक्ति सक्षम हैं।

वीएस 2010 और पुराने के लिए इसी तरह की नियमित अभिव्यक्ति है

^~(:[email protected]//.+)~(:[email protected]\{:[email protected])~(:[email protected]\}:[email protected])~(:[email protected]/#).+

स्पष्ट रूप से उपकरण आसान हैं, लेकिन मुझे शक्तियों में यह अच्छा लगता है :)

इस स्क्रिप्ट को .sln फ़ाइल में सभी .csproj संदर्भ मिलते हैं, और उसके बाद प्रत्येक csproj फ़ाइल में यह संकलन के लिए शामिल फ़ाइलों को रेखांकित करता है। संकलन के लिए शामिल प्रत्येक फ़ाइल के लिए यह गुणों के साथ एक वस्तु बनाता है: समाधान, परियोजना, फ़ाइल, रेखाएं। यह इन सभी वस्तुओं को एक सूची में संग्रहीत करता है, और फिर आवश्यकतानुसार डेटा को समूह और प्रोजेक्ट करता है।

#path to the solution file e.g. "D:\Code\Test.sln"
$slnFile = "D:\Code\Test.sln"


#results
$results = @()

#iterate through .csproj references in solution file
foreach($projLines in get-item $slnFile | Get-Content | Select-String '".*csproj')
{
    $projFile = [System.IO.Path]::Combine([System.IO.Path]::GetDirectoryName($slnFile), [regex]::Match($projLines,'[^"]*csproj').Value)
    $projFolder = [System.IO.Path]::GetDirectoryName($projFile)

    #from csproj file: get lines for files to compile <Compile Include="..."/>
    $includeLines = get-item $projFile | Get-Content | Select-String '<Compile Include'


    #count of all files lines in project
    $linesInProject = 0;
    foreach($fileLine in $includeLines)
    {
        $includedFilePath = [System.IO.Path]::Combine($projFolder, [Regex]::Match($fileLine, '"(?<file>.*)"').Groups["file"].Value)
        $lineCountInFile = (Get-Content $includedFilePath).Count      
        $results+=New-Object PSObject -Property @{ Solution=$slnFile ;Project=$projFile; File=$includedFilePath; Lines=$lineCountInFile }
    }
}

#filter out any files we dont need
$results = $results | ?{!($_.File -match "Designer")}


#print out:

"---------------lines per solution--------------"
$results | group Solution | %{$_.Name + ": " + ($_.Group | Measure-Object Lines -Sum).Sum}
"---------------lines per peoject--------------"
$results | group Project | %{$_.Name + ": " + ($_.Group | Measure-Object Lines -Sum).Sum}

विजुअल स्टूडियो 2015 में विश्लेषण मेनू पर जाएं और "कोड मेट्रिक्स की गणना करें" का चयन करें।


मैं एक फ़ोल्डर संरचना में लाइनों की गिनती के लिए एक त्वरित और गंदे शक्तिशक्ति लिपि के साथ आया था। यह लगभग अन्य उपकरणों में संदर्भित कुछ अन्य उपकरणों के रूप में पूर्ण रूप से पूर्ण रूप से प्रदर्शित नहीं है, लेकिन मुझे लगता है कि यह एक परियोजना या समाधान में एक दूसरे के सापेक्ष कोड फ़ाइलों के आकार की मोटा तुलना प्रदान करने के लिए पर्याप्त है।

लिपि यहां पाई जा सकती है:

https://gist.github.com/1674457


मैंने Ctrl + Shift + F का उपयोग किया। इसके बाद, \n खोज बॉक्स में रखें और नियमित अभिव्यक्ति बॉक्स सक्षम करें। फिर खोज परिणामों में, स्क्रीन के अंत में खोज की गई फ़ाइलों की संख्या और कोड की रेखाएं मिलती हैं।


cloc एक उत्कृष्ट कमांडलाइन है, पर्ल-आधारित, विंडोज-एक्जिक्यूटेबल जो रिक्त लाइनों, टिप्पणी लाइनों और कोड के स्रोत लाइनों को तोड़ देगा, जो फ़ाइल स्वरूपों द्वारा समूहीकृत है।

अब यह विशेष रूप से वीएस समाधान फ़ाइल पर नहीं चलेगा, लेकिन यह निर्देशिकाओं के माध्यम से पुन: कार्य कर सकता है, और आप फिट होने पर फ़ाइल नाम फ़िल्टर सेट कर सकते हैं।

यहां उनके वेब पेज से नमूना आउटपुट है:

prompt> cloc perl-5.10.0.tar.gz
    4076 text files.
    3883 unique files.                                          
    1521 files ignored.

http://cloc.sourceforge.net v 1.07  T=10.0 s (251.0 files/s, 84566.5 lines/s)
-------------------------------------------------------------------------------
Language          files     blank   comment      code    scale   3rd gen. equiv
-------------------------------------------------------------------------------
Perl               2052    110356    112521    309778 x   4.00 =     1239112.00
C                   135     18718     22862    140483 x   0.77 =      108171.91
C/C++ Header        147      7650     12093     44042 x   1.00 =       44042.00
Bourne Shell        116      3402      5789     36882 x   3.81 =      140520.42
Lisp                  1       684      2242      7515 x   1.25 =        9393.75
make                  7       498       473      2044 x   2.50 =        5110.00
C++                  10       312       277      2000 x   1.51 =        3020.00
XML                  26       231         0      1972 x   1.90 =        3746.80
yacc                  2       128        97      1549 x   1.51 =        2338.99
YAML                  2         2         0       489 x   0.90 =         440.10
DOS Batch            11        85        50       322 x   0.63 =         202.86
HTML                  1        19         2        98 x   1.90 =         186.20
-------------------------------------------------------------------------------
SUM:               2510    142085    156406    547174 x   2.84 =     1556285.03
-------------------------------------------------------------------------------

तीसरी पीढ़ी के समकक्ष पैमाने का अनुमान है कि यह तीसरी पीढ़ी की भाषा में कितना कोड लेगा। बहुत उपयोगी नहीं है, लेकिन वैसे भी दिलचस्प है।


आप मुफ्त उपकरण SourceMonitor उपयोग कर सकते हैं

बहुत सारे उपाय देता है: कोड की रेखाएं, विवरण गणना, जटिलता, ब्लॉक गहराई

चार्ट के माध्यम से ग्राफिकल आउटपुट है


भविष्य के पाठकों के लिए मैं विजुअल स्टूडियो 2010 के लिए डीपीएक्स एक्सटेंशन की सलाह देना चाहता हूं।

इसमें एक लाइन काउंटर समेत निर्मित यूटिलिटीज का भार है जो कहता है कि कितनी लाइन खाली, कोड और इत्यादि हैं।







line-count