आप किसी Visual Studio समाधान में कोड की पंक्तियों को कैसे गिनते हैं?

800

क्या संपूर्ण समाधान में कोड की पंक्तियों की संख्या ज्ञात करना संभव है? मैंने एमजेड-टूल्स के बारे में सुना है , लेकिन क्या एक खुला स्रोत बराबर है?

visual-studio  code-metrics  lines-of-code  line-count 
— फर्मिन
स्रोत
24
मैं सहमत हूं कि यह बहुत मदद नहीं करता है, लेकिन अगर प्रबंधन इसके लिए कह रहा है ...
— Fermin
33
एलओसी महज एक मीट्रिक है और 2 मामलों में कणिकीय रूप से अंतर्संबंधित है: 1) एक विचार प्राप्त करने के लिए कि कोड आधार कितना बड़ा है (जब आप एक नई टीम में शामिल हों 2) अपनी प्रगति को मापने के लिए अपनी कोड आधार को और अधिक कॉम्पैक्ट बनाने की कोशिश करते समय
— Pirr Owsiak
191
यहाँ कुछ लोग कह रहे हैं कि अच्छी सोच दिए बिना कोड की पंक्तियों को गिनना बेकार है। यह काफी उपयोगी है क्योंकि यह एक मीट्रिक है जिसे आमतौर पर कम से कम किया जाना चाहिए। यह समाधान की जटिलता (दक्षता नहीं) को मापने का एक सरल तरीका है और यदि समस्या को सरल माना जाता है, तो कोड की अधिक लाइनें, आमतौर पर गुणवत्ता कम होती है। एक और बात यह है कि लोगों को जवाब देने में परेशान क्यों किया जाए अगर यह कहना कि सवाल बुरा है? यदि कोई शिक्षक आपको अपना प्रश्न बताए, तो उससे नहीं पूछा जाना चाहिए।
77
VS2010 में एक इन-बिल्ट टूल है जो कोड की सभी लाइनों और अन्य मानों को भी गिनता है: गो टू व्यू -> अन्य विंडोज -> कोड मेट्रिक्स परिणाम। कोने में एक छोटा बटन जो कैलेंडर की तरह दिखता है, उस पर क्लिक करें, टूलटिप को आत्मा के लिए कोड मेट्रिक्स की गणना करना चाहिए, और वीएस को यह करने देना चाहिए।
— user959631
64
व्यक्ति को हमेशा आपको यह बताने की आवश्यकता नहीं है कि वे कोड क्यों गिनना चाहते हैं। जब सवाल यह है कि बस कहा जाता है, तो मामला अप्रासंगिक क्यों है। बस उसके सवाल का जवाब दो। मुझे उससे नफरत है। यह पूछने का समय है कि क्यों स्पष्ट रूप से आपको ज़रूरत है और फिर ऐसे समय हैं जब आप नहीं करते हैं (जब आप व्यक्तिगत रूप से एक आवश्यकता नहीं देखते हैं ... और सिर्फ अहंकार में पोस्टर को खराब कर रहे हैं)।
— पॉजिटिव

जवाबों:

524

विजुअल स्टूडियो 2010 अल्टीमेट में यह बिल्ट-इन है:

विश्लेषण → कोड मेट्रिक्स की गणना

— Herter
स्रोत
12
अंतिम और प्रीमियम, मुझे लगता है
— स्टेफन ड्रैगनेव
39
चेतावनी: यह कई अन्य चीजों के अलावा बस लाइन की गिनती करता है। यह "मेनटेनेबिलिटी इंडेक्स", "साइक्लोमैटिक कॉम्प्लेक्सिटी", "डेथ ऑफ इनहेरिटेंस", और "क्लास कपलिंग" को भी सूचीबद्ध करता है, जो सभी गणना करने के लिए बहुत जटिल हैं, और आप इसके कुछ हिस्सों के लिए मैट्रिक्स नहीं चला सकते हैं। इसका मतलब यह है कि यदि आपका कोड-आधार विशेष रूप से बड़ा है, तो आप इसके इंतजार में घंटों बैठे रह सकते हैं। यदि आप सभी चाहते हैं कि लाइन-काउंट है, तो वहाँ बहुत तेजी से समाधान है।
— डारेल हॉफमैन
4
vs2012 अल्टिमेट =) पर भी
— oCcSking
9
वी.एस. 2013 विश्लेषण किया है -> की गणना कोड मैट्रिक्स
— दिनेश राजन
42
बहुत बुरा यह देशी C ++ परियोजनाओं के साथ काम नहीं करता है (कम से कम यह VS2013 में नहीं है)।
— कैमरन
844

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

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

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>

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

— ग्रेग डी
स्रोत
19
(जब मैंने कभी भी लाइन काउंट्स की आपूर्ति करने के लिए कहा था, जब ऊपरी प्रबंधन यह पता लगा रहा था कि हमारे सभी उत्पादों को विदेशों में स्थानांतरित करने में कितना समय लगेगा ताकि वे हमारी घरेलू साइट को बंद कर सकें।)
— ग्रेग डी
8
(हां, इसमें कोडजेन फाइलें और टिप्पणियां शामिल हैं। नहीं, यह मुझे परेशान नहीं करता है। डिजाइनर, जीन कोड, और टिप्पणियों को भी बनाए रखने की जरूरत है।)
— ग्रेग डी
27
बहुत अच्छा, पूरी तरह से शक्तियों के बारे में भूल गया। यह cmd के लिए डिफ़ॉल्ट रिप्लेसमेंट बन जाना चाहिए
— lubos hasko
4
अति उत्कृष्ट! आपकी समाप्ति टिप्पणी वास्तव में इसे पूरा करती है, यह एक तुच्छ कार्य है, इसलिए एक गैर-तुच्छ टूल का उपयोग क्यों करें? हालांकि मुझे वास्तव में लगता है कि इसे वीएस के सभी संस्करणों में शामिल किया जाना चाहिए।
— सून रिवर्स
13
यदि आप XAML के लिए उत्पन्न बैकिंग फ़ाइलों को बाहर करना चाहते हैं, तो आप सिर्फ एक -एक्सक्लूड स्विच जोड़ सकते हैं: (dir -exclude *.g.cs -include *.cs,*.xaml -recurse | select-string .).Count
— EZ हार्ट
348

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

आप [^\n\s]\r\nरिक्त और स्पेस-ओनली लाइनों (टिप्पणियों में Zach को क्रेडिट) को छोड़ने के लिए उपयोग कर सकते हैं ।

— NicolásKittsteiner
स्रोत
16
इस समाधान में गलत तरीके से रिक्त लाइनें, टिप्पणियाँ, प्रलेखन और विभाजन विवरण शामिल हैं। कई अनुप्रयोगों के लिए, जिन्हें कोड की पंक्तियों के रूप में नहीं गिनना चाहिए।
— जे। बैक्सटर
1
हालाँकि यह थोड़ा गलत है (यदि आप वास्तव में अपने कोड में \ n का उपयोग करते हैं, तो वह लाइन डबल काउंटेड होगी), यह अभी भी सबसे अच्छा जवाब है यदि आपको बिना किसी 3 पार्टी टूल के कोड की एक रोम की आवश्यकता है
— जोसेफ ड्यूटी
1
आप Look at these file types:केवल एक विकल्प ड्रॉपडाउन का चयन करके एक विशिष्ट फ़ाइल प्रकार का चयन कर सकते हैं enable regular expressions box।
— मोशी
1
बहुत छोटी परियोजनाओं के लिए काम करता है ... जब आपके पास कोड की 100 मिलियन लाइनें होती हैं तो इसमें कुछ समय लगेगा।
— मार्श
10
[^\n\s]\r\nरिक्त लाइनों को छोड़ देता है, यहां तक ​​कि उनमें रिक्त स्थान के साथ।
— ज़ैच मिर्ज़ेवेस्की
219

VS2005, 2003 और 2002 के लिए एक ओपन सोर्स लाइन काउंटर यहां उपलब्ध है:

http://www.wndtabs.com/

यहां कोडप्रोजेक्ट पर कोड के साथ पूर्ण एक लाइन काउंटिंग वीएस एडिन बनाने की भी चर्चा है

http://www.codeproject.com/KB/macros/LineCounterAddin.aspx

इसके अलावा स्लिक एडिट गैजेट्स का एक अच्छा लाइन-काउंटर है, यहां:

http://www.slickedit.com/products/slickedit

और Microsoft Visual Studio टीम सिस्टम 2008 में एक अच्छी लाइन काउंटर शामिल है।

हालांकि याद रखें:

कोड की लाइनों द्वारा प्रोग्रामिंग प्रगति को मापना वजन द्वारा विमान निर्माण प्रगति को मापने के समान है। बिल गेट्स

— अली पर्र
स्रोत
1
अक्सर कोड की पंक्तियों की गिनती बस सादा मूर्खतापूर्ण होती है, और मात्रा में गुणवत्ता नहीं होती है। हालाँकि, 545,000 पौंड (545,000 पौंड !!) डालने वाली एक विशाल टीम हवा में ड्रीमलाइनर पराबैंगनी को लॉन्च करने की तुलना में एक पूरी तरह से अलग उपलब्धि है, जिसे मैंने अपने गैरेज में अकेले ही बनाया था। और अगर आप विंडोज में कोड की लाइनों की संख्या के बारे में सोचते हैं, तो शायद श्री बिल का मतलब अलग तरीके से होता है, जैसा कि आमतौर पर लिया जाता है ...?
— बिना सोचे
18
इनमे से कोई भी Visual Studio 2010 पर लागू नहीं होता है, और स्लिचिट लिंक टूट गया है।
— MGOwen
57
आपको "विश्लेषण> कोड मेट्रिक्स" के तहत विज़ुअल स्टूडियो 2010 अल्टीमेट में एलओसी सुविधा मिलती है, मुझे आशा है कि मैंने इसे सही अनुवाद किया है। मेरे पास जर्मन संस्करण है। वहाँ यह "विश्लेषण"> "कोडिमेट्रीकेन बेरेचन" है
— OneWorld
2
विजुअल स्टूडियो 2012 के लिए एलओसी मीट्रिक ANALYZE
— tetri
2
साथ ही, VS2012 में यह सुविधा अल्टीमेट और प्रीमियम एडिशन (और अब प्रोफेशनल के साथ भी) शामिल है।
— स्वैलर्स - मोनिका
81

यहां विजुअल स्टूडियो 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 के लिए XML

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

HTML टिप्पणियाँ:

<!-- 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 */
            }
        }

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

— हॉवर्ड रेनोलेट
स्रोत
18
बिना कमेंट के प्यार करना। इसकी अनुमति नहीं दी जानी चाहिए। मेरे समाधान के बारे में क्या काम नहीं करता है ??? मुझे वोटों की भी परवाह नहीं है, मैं सिर्फ VS2012-2013 उपयोगकर्ताओं के लिए एक अपडेट पोस्ट करना चाहता था।
— हावर्ड रेनोलेट
सभी उत्पन्न कोड (असेंबलीइन्फो इत्यादि) को फ़िल्टर करना मुश्किल है, इसलिए कोड मेट्रिक्स का विश्लेषण / गणना करना पसंद किया जाना चाहिए।
— एमकेस्पर
4
महान काम, लेकिन विकल्प विकल्प अनुभाग के तहत नियमित अभिव्यक्ति अभिव्यक्ति चेकबॉक्स का उल्लेख करें । यह बहुत आसान बनाता है
— गोगुट्ज़
@MKesper लेकिन सी + + के लिए काम नहीं करता है
— d7samurai
एक सरल संस्करण यदि कोई XML नहीं है, न ही HTML ... ^ ((([^ \ r \ n]) \ s) * [[\ _ s +?]] + [^ \ N] * $।
— LastBlow
80

इस टिप को मिला: वीएस फाइंड एंड रिप्लेस के साथ LOC

एक प्लगइन नहीं है, हालांकि यदि आप क्या देख रहे हैं।

— मैड्स एंडरसन
स्रोत
मुझे यह पसंद है, लेकिन मुझे लगता है कि मुझे वहां अभिव्यक्ति में एक छोटी सी त्रुटि मिली। VB.Net के लिए मुझे लगता है कि यह ^ ~ (: Wh @ ') ~ (: Wh @ \ #) + होना चाहिए और C # I के लिए ^ ~ (: Wh @ //) ~ (: Wh @ \ {: Wh @) ~ (: Wh @ \}: Wh @) ~ (: Wh @ # #)। इस तरह से रिक्त टिप्पणी पंक्तियों और संकलक निर्देशों को ठीक से निपटाया जाता है। यह मेरे लिए वैसे भी VB.NET के साथ बेहतर काम करता था, और C # मैंने परीक्षण नहीं किया है।
— 14:12 पर user12861
^ ~ (: Wh @ //) ~ (: Wh @ \ {: Wh @) ~ (: Wh @ \}: Wh @) ~ (: Wh @ \ #) ~ (: Wh @ $) + समाप्त हो गया। C # के लिए बेहतर काम करते हुए, मुझे कुछ लाइनें मिल रही थीं, जिनमें सिर्फ व्हॉट्सएप था।
— 14:12 पर user12861
क्या यह सभी टिप्पणी की गई पंक्तियों को भी नहीं गिनता है? कृपया कोड की लाइनें!
— हाइडफनी
4
यहाँ एक है कि मैंने VS2012 में काम किया है (एक पोस्ट 2010 के रूप में पुरानी है) और केवल कोड की लाइनें गिनाता है। यह निर्देश, घुंघराले ब्रेसिज़, xml निर्देश, रिक्त लाइनों, आदि का उपयोग करके सभी टिप्पणियों को बाहर करता है .... आपको केवल एक वास्तविक कोड देने के लिए गिनती: ^ ((? (\ S **)) (?! (\ S *)! - \ -?! \>)) ((\ s * \ <\ \ - \ -?!?!)) ((\ s * \ n)) ((\ रों ** \ /)) (?! (\ s * \ / *)) (?! (\ s * \ / \ / \ /)) (?! (\ s * \ / \ /)) (?! (\ s * \})) (? ! (\
— _
65

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

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

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

प्रॉम्प्ट> क्लॉक पेर्ल-5.10.0.tar.gz
    4076 पाठ फ़ाइलें।
    3883 अद्वितीय फ़ाइलें।                                          
    1521 फाइलों को नजरअंदाज किया।

http://cloc.sourceforge.net v 1.07 T = 10.0 s (251.0 फाइलें / एस, 84566.5 लाइनें / सेकंड)
-------------------------------------------------- -----------------------------
भाषा फाइलें खाली टिप्पणी कोड पैमाने 3 जी। समतुल्य
-------------------------------------------------- -----------------------------
पर्ल 2052 110356 112521 309778 x 4.00 = 1239112.00
C 135 18718 22862 140483 x 0.77 = 108171.91
C / C ++ हैडर 147 7650 12093 44042 x 1.00 = 44042.00
बॉर्न शेल 116 3402 5789 36882 x 3.81 = 140520.42
लिस्प 1 684 2242 7515 x 1.25 = 9393.75
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
डॉस बैच 11 85 50 322 x 0.63 = 202.86
HTML 1 19 2 98 x 1.90 = 186.20
-------------------------------------------------- -----------------------------
एसयूएम: 2510 142085 156406 547174 x 2.84 = 1556285.03
-------------------------------------------------- -----------------------------

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

— मार्क रुशकॉफ
स्रोत
1
यह उपयोग करने के लिए महान और सुपर आसान है। ढूँढें / बदलें समाधान की तुलना में बहुत आसान है और अधिक स्पष्ट है कि यह वास्तव में वीएस कोड मेट्रिक्स विकल्प से क्या कर रहा है। बस choco install clocऔर फिर cloc .अपने समाधान में dir। काम हो गया!
— रोरी
1
मैंने CLOC वेबसाइट से Windows EXE डाउनलोड किया और इसे अपने Visual Studio 2017 वेबसाइट प्रोजेक्ट फ़ोल्डर में चलाया। एक जादू की तरह काम किया। मैं --by-file-by-lang ऑप्शन को पसंद करता हूं, जो व्यक्तिगत और फ़ाइल के अनुसार लाइन काउंट को सूचीबद्ध करता है, जो सबसे बड़े से लेकर सबसे छोटे तक छांटा जाता है।
— हम्बड्स
42

यहाँ उत्तर थोड़ा पुराना है, 2008 के समय से हो सकता है। क्योंकि 2010-2013 के नए विज़ुअल स्टूडियो संस्करणों में, यह सुविधा पहले से ही अंतर्निहित है। इस प्रकार इसके लिए किसी भी एक्सटेंशन या टूल का उपयोग करने का कोई कारण नहीं है।

कोड की पंक्तियों को गिनने की सुविधा - मेट्रिक्स की गणना करें। इसके साथ आप प्रत्येक प्रोजेक्ट या समाधान के लिए अपने मेट्रिक्स (LOC, Maintaince index, Cyclomatic index, Depth of inheritence) की गणना कर सकते हैं।

सॉल्यूशन एक्सप्लोरर में सॉल्यूशन या प्रोजेक्ट पर राइट क्लिक करें,

यहां छवि विवरण दर्ज करें

और "मैट्रिक्स की गणना करें" चुनें

यहां छवि विवरण दर्ज करें

बाद में विश्लेषण और एकत्रीकरण के डेटा को एक्सेल में आयात किया जा सकता है। एक्सेल में भी आप अपने मेट्रिक्स से उत्पन्न कक्षाओं, या अन्य शोर को फ़िल्टर कर सकते हैं। लाइन्स ऑफ कोड LOC सहित इन मेट्रिक्स को बिल्ड प्रोसेस के दौरान भी इकट्ठा किया जा सकता है, और बिल्ड रिपोर्ट में शामिल किया जा सकता है

— Regfor
स्रोत
2
विजुअल स्टूडियो 2010 में भी यह मैट्रिक्स है। वास्तव में VS2012 में कुछ भी नया नहीं है।
— माइक चाली
1
हां, लेकिन यहां उत्तर बनाम 2008 के समय से हैं और थोड़ा सा पुराना है, किसी भी चीज का उपयोग क्यों करते हैं या जब यह बिल्ट-इन फीचर है तो कुछ एक्सटेंशन इंस्टॉल करते हैं। और यहां तक ​​कि यह नई सुविधा नहीं है कई लोग इसके बारे में नहीं जानते हैं।
— Regfor
@ मायकेचाली मई दूसरा परिचय वाक्य आपको भ्रमित कर सकता है, इसलिए मैंने इस तरह के भ्रम से बचने के लिए इसे फिर से लिखा है।
— Regfor
मेरे पास एक n- लेयर सॉल्यूशन है लेकिन वह इस एरर को प्रदर्शित करता है: "एक्सेलेरेशन के टारगेट द्वारा एक्ससेप्शन को फेंक दिया गया है।" क्यों?
— user197508
5
यह कोड की लाइनें नहीं है, लेकिन संकलित लाइनें (यानी इसे आईएल में बदल जाने के बाद)। मुझे लगता है कि फर्मिन पूर्व संकलित लाइनों की तलाश में था।
— mikeschuld
29

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

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

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

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

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

^~(:Wh@//.+)~(:Wh@\{:Wh@)~(:Wh@\}:Wh@)~(:Wh@/#).+
— user2711915
स्रोत
19

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

— क्रिस्टोफर क्लेन
स्रोत
12
विजुअल स्टूडियो टीम सिस्टम 2008 अप्रबंधित कोड की गणना करने का प्रबंधन नहीं करता है। ;)
— क्रिश्चियन
17

भविष्य के पाठकों के लिए मैं Visual Studio 2010 के लिए DPack एक्सटेंशन की सलाह देना चाहूंगा ।

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

— एशले डेविस
स्रोत
— फिलिप एम
11

एक सरल समाधान सभी फाइलों में खोज करना है। वाइल्डकार्ड का उपयोग करते समय "*" टाइप करें। जो सभी लाइनों से मेल खाता होगा। खोज परिणाम विंडो के अंत में आपको सॉर्ट की एक पंक्ति दिखनी चाहिए:

Matching lines: 563 Matching files: 17 Total files searched: 17

बेशक, यह बड़ी परियोजनाओं के लिए बहुत अच्छा नहीं है, क्योंकि सभी लाइनों का निर्माण किया जाता है और मेमोरी में लोड किया जाता है ताकि खोज परिणाम विंडो पर भेजा जा सके।

संदर्भ:

— Sogartar
स्रोत
4

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

इस स्क्रिप्ट को .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}
— anakic
स्रोत
3

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

— सुनील
स्रोत
3

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

— ट्रैविस
स्रोत
1

आप Visual Studio 2010 में प्रोजेक्ट लाइन काउंटर ऐड-इन का उपयोग कर सकते हैं। आम तौर पर यह विज़ुअल स्टूडियो 2010 के साथ काम नहीं करता है, लेकिन यह यहाँ से एक सहायक .reg फ़ाइल के साथ है: http://www.onemanmmo.com/index। php? cmd = newsitem और टिप्पणी = news.1.41.0

— रॉबर्ट बेसलर
स्रोत
1

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

स्क्रिप्ट यहां मिल सकती है:

https://gist.github.com/1674457

— जेसी टैबर
स्रोत
0

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

— Atters
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.