# त्वरित सी# जाँच के लिए सीएसएक्स स्क्रिप्ट उपयोग किया जा रहा है को a C# कोड का पूर्ण प्रोजेक्ट चला रहा है? C# स्क्रिप्ट फ़ाइल ()`.csx`) आप लिखने के लिए और चलाएँ C# कोड एक स्क्रिप्टिंग भाषा की तरह. `Program.cs`, नहीं `.csproj`, बस लिखने और चलाने के लिए नहीं क़दम - बस लिखने और चलाने के लिए बिल्कुल ही नहीं । मैं पूरे cukecocio बाहर रोल के लिए मैं सोचा था कि मैं कैसे इस्तेमाल करता हूँ `.csx` इस तथा अन्य परियोजनाओं में जाँच के लिए फ़ाइलें. [TOC] ## CSX vs .नेट 10 फ़ाइल - बेस्ड ए पानी में डालने से पहले, चलो कमरे में हाथी को संबोधित करते हैं: `.cs` फ़ाइलें सीधे साथ `dotnet run app.cs`. यह सीएसएक्स से कैसे तुलना करता है? ### . NET 10 फ़ाइल Baphphpht. (अब उपलब्ध!) 10 के साथ, आप सीधे ही एकल फ़ाइल C# चला सकते हैं: ```bash # .NET 10 - available now! dotnet run app.cs ``` **विशेषताएँ:** - के डी के लिए देशी - कोई अतिरिक्त औज़ार आवश्यक नहीं - इस्तेमाल `.cs` एक्सटेंशन - नॉ हो संदर्भों के द्वारा `#:package` निर्देश - पूरा दिन - सामान्य प्रोजेक्ट संस्थापित करें ```csharp // app.cs - .NET 10 style #:package Newtonsoft.Json@13.0.3 using Newtonsoft.Json; var obj = new { Name = "Test", Value = 42 }; Console.WriteLine(JsonConvert.SerializeObject(obj)); ``` ### सीएसएक्स स्क्रिप्ट (अब उपलब्ध है) केएसएक्स के द्वारा `dotnet-script` 2017 से आस - पास है: ```bash # Available today dotnet script app.csx ``` **विशेषताएँ:** - .ENT 6, 7, 8, 9 के साथ काम करता है 10 - महासागरीय वातावरण तथा औज़ार - अंतःक्रियात्मक खोज हेतु आरएलई मोड - Eenen और लड़ाई की परीक्षा ```csharp // app.csx - CSX style #r "nuget: Newtonsoft.Json, 13.0.3" using Newtonsoft.Json; var obj = new { Name = "Test", Value = 42 }; Console.WriteLine(JsonConvert.SerializeObject(obj)); ``` ### आपको किस चीज़ का उपयोग करना चाहिए? INVERGENT CX (डोनेट- स्क्रिप्ट) . NERT 10 फ़ाइल एस्क |---------|---------------------|-------------------| | **आवाही उपयोगिता** . WERT 6+RELL. TET 10 बराबर | **संस्थापन** | `dotnet tool install -g dotnet-script` एसकेआईएम में अंतर्निर्मित | **फ़ाइल एक्सटेंशन** | `.csx` | `.cs` | | **लागू नहीं करें सिंटेक्सQXml** | `#r "nuget: Pkg, Ver"` | `#:package Pkg@Ver` | | **आरएलईसी मोड** 2002- 2006 जी नहीं | **आईडीई समर्थन** सेंटीमीटर अच्छा (वीएस कोड, सवार) सरफेश | **डिबगिंग** एनटीएलएम जी हाँ (एनएक्सपीएक्स) (N) **मेरी सिफारिश:** - **कोशिश करें . NET 10 फ़ाइल apps पहले** - स्थानीय समर्थन का अर्थ है कम औज़ारिंग के ऊपर - **डीएसएक्स में वापस गिरें** अगर आपको निरीक्षण विधि की आवश्यकता है या किसी पुराने संस्करण पर हैं - दोनों के बीच आसानी से भिन्‍न - भिन्‍न - भिन्‍न धारणाएँ हैं इस लेख के बाकी भाग सीएसएक्स को कवर करते हैं जो अभी भी महान कार्य करता है और कुछ विशेषताएँ (जैसे कि आर.टीटीटी 10 फ़ाइल ऐक्स) है। ## सीएसएक्स क्या है? CSX (C# स्क्रिप्ट) फ़ाइलें हैं C# कोड फ़ाइल हैं जो सीधे बिना किसी परियोजना में कम्पाइल किए जा सकते हैं. इसके बारे में सोचो जैसे - C# - आप कोड लिखते हैं, आप परिणाम देखते हैं. ```csharp // hello.csx Console.WriteLine("Hello from C# Script!"); ``` चलाएँ: ```bash dotnet script hello.csx ``` यह है. `Main()` विधि, कोई नेमस्पेस, क्लास रैपर आवश्यक नहीं. ## दो-नेट- स्क्रिप्ट संस्थापित किया जा रहा है केएसएक्स फ़ाइलें चलाने का सबसे लोकप्रिय तरीका है के द्वारा [डेकोनेट- स्क्रिप्ट](https://github.com/dotnet-script/dotnet-script): ```bash dotnet tool install -g dotnet-script ``` सत्यापित करें: ```bash dotnet script --version ``` ## जाँच में CSX अनुरूप "कैसे" में बदलाव करने से पहले, चलो समझ जाएँ कि "जब." CSX स्क्रिप्ट परीक्षण के लिए एक विशिष्ट स्थान पर स्थित है: ``` ┌─────────────────┐ │ E2E Tests │ ← Full system, slow, expensive │ (Playwright) │ ─┼─────────────────┼─ │ Integration Tests │ ← Multiple components, database │ (xUnit + DB) │ ─┼───────────────────┼─ │ CSX Scripts │ ← Quick validation, exploration │ (Ad-hoc testing) │ ★ YOU ARE HERE ★ ─┼─────────────────────┼─ │ Unit Tests │ ← Single class, mocked deps │ (xUnit, NUnit, etc) │ ─┴─────────────────────────┴─ ``` ### CSX स्क्रिप्ट्स "मिशिश परीक्षण" के रूप में CSX स्क्रिप्ट औपचारिक परीक्षण के लिए एक प्रतिस्थापित नहीं कर रहे हैं - वे एक हैं **अवयव**उनके बारे में सोचिए: - **प्री- डिज़ाइन की ध्वनि** - एक एपीआई काम करता है इसके आसपास एक सेवा निर्माण से पहले - **डिबगिंग मदद** - अपने पूरे एप्पल का निर्माण किए बिना और मुद्दों को दोबारा बनाने के लिए फिर से करें - **एक्लिप्टिक जाँच** - समझते हैं कि एक पुस्तकालय इकाई जाँच से पहले कैसे व्यवहार करता है - **धूम्रपान जाँच** - त्वरित विवेक असली सेवाओं के खिलाफ जांच करता है (आधार, एपीआई, कतार) ### विकास कार्य फूल यहाँ कैसे सीएसएसएक्स एक सामान्य विशेषता चक्र में फिट होता है: ``` 1. EXPLORE (CSX Script) └─→ "Does this API even work? What's the response format?" └─→ Write a quick script to call the API and see the output 2. PROTOTYPE (CSX Script) └─→ "How should I structure this service?" └─→ Test different approaches without project scaffolding 3. IMPLEMENT (Production Code) └─→ Build the actual service with proper error handling, DI, etc. └─→ You already know the API works from step 1! 4. TEST (xUnit/NUnit) └─→ Write formal unit tests with mocks └─→ Write integration tests against test database 5. DEBUG (CSX Script) └─→ Production issue? Write a script to reproduce it └─→ Faster than adding logging, rebuilding, deploying ``` ### असली उदाहरण: उममी के साथ मिलकर निर्माण करना जब मैं इस ब्लॉग के लिए उममी एकीकरण का निर्माण किया, मेरा काम फूल था: 1. **सीएसएक्स: रॉ API को जाँचें** - क्या प्रमाणीकरण कार्य करता है? 2. **CSX: समय क्षेत्र परिवर्तन जाँच** - किसी भी उत्पादन कोड को लिखने से पहले यहाँ एक बग मिला! 3. **लागू करें: उममीसी बिल्ड करें** - भरोसा के साथ क्योंकि मैं पहले से ही एपीआई को रद्द कर दिया था 4. **x इकाई: इकाई जाँच लिखें** - नकली Miolial, सीरियलीकरण तर्क परीक्षण 5. **CSX: डिबग उत्पादन अंक** - अज़ाब खाली वापस आ रहा है ? स्क्रिप्ट समस्या को अलग करने के लिए सीएसएक्स स्क्रिप्ट मेरी इकाई जाँच की जगह नहीं ले गए - वे **मुझे लिखने के कोड से रोका जो काम नहीं करता** और मेरी मदद की **डिबग अंक तेजी से डिबग करें** जब वे घटित हुए । ## जाँच के लिए सीएसएक्स क्यों इस्तेमाल करें? ### 1. शून्य क्विन्सन कॉल करने के लिए पारंपरिक तरीका: 1. नया कंसोल परियोजना बनाएँ 2. एनएओ पैकेज जोड़ें 3. लिखें `Program.cs` 4. बिल्ड 5. चलाएँ 6. जब कार्य पूरा हो तो परियोजना मिटाएँ डीएसएक्स पास: 1. स्क्रिप्ट लिखें 2. स्क्रिप्ट चलाएँ ### 2 इनलाइन Nue संदर्भ पैकेज की आवश्यकता है? इसे सीधे आपके स्क्रिप्ट में संदर्भ: ```csharp #r "nuget: Newtonsoft.Json, 13.0.3" #r "nuget: RestSharp, 110.2.0" using Newtonsoft.Json; using RestSharp; var client = new RestClient("https://api.github.com"); var request = new RestRequest("users/scottgal", Method.Get); request.AddHeader("User-Agent", "CSX-Test"); var response = await client.ExecuteAsync(request); Console.WriteLine(JsonConvert.SerializeObject( JsonConvert.DeserializeObject(response.Content), Formatting.Indented)); ``` पहले डाउनलोड पैकेज चलाएँ. ### 3. संदर्भ स्थानीय DLLes अपने खुद की लाइब्रेरी की जाँच करें? इसे सीधे संदर्भ: ```csharp #r "bin/Debug/net9.0/MyLibrary.dll" using MyLibrary; var result = MyClass.DoSomething(); Console.WriteLine(result); ``` ### 4. अन्य स्क्रिप्टों के संदर्भ घन स्क्रिप्ट को नया भाग में विभाजित करें: ```csharp #load "helpers.csx" #load "config.csx" // Use functions/classes from loaded scripts var config = LoadConfig(); var result = ProcessData(config); ``` ## इस परियोजना से वास्तविक उदाहरण ये नकली उदाहरण नहीं हैं - वे वास्तविक स्क्रिप्ट हैं मैं डिबग करने के लिए उपयोग कर इस ब्लॉग कोड को खराब करने के लिए उपयोग कर रहे हैं। प्रत्येक ने विकास के दौरान एक वास्तविक समस्या को हल किया। ### एपीआई विचरक जाँच **समस्या:** मेरा उममी एकीकरण खाली डेटा वापस आ रहा था. डिबगिंग के घंटों के बाद, मुझे संदेह था कि समय-समय परिवर्तन गलत था - उममीएम से आशा है मिली है, लेकिन मुझे यकीन नहीं था कि अगर मेरा satt कोड सही प्रारूप तैयार कर रहा था. **सी.एक्स?** मैं उत्पादन कोड में लॉगिंग हो सकता है, फिर से बनाया, तैनात किया गया, और लॉग की जाँच की. या मैं 30 सेकंड में एक त्वरित स्क्रिप्ट लिख सकता था. ```csharp #!/usr/bin/env dotnet-script // This script helped debug an issue where the Umami API was returning empty data. // The API expects Unix timestamps in milliseconds, and I suspected my conversion was wrong. // Start with known values we can verify var now = DateTime.UtcNow; var yesterday = now.AddHours(-24); // The "O" format specifier gives us ISO 8601 format - precise and unambiguous // Example output: "2025-11-24T10:30:45.1234567Z" Console.WriteLine($"Now: {now:O}"); Console.WriteLine($"Yesterday: {yesterday:O}"); // The Umami API expects Unix timestamps in MILLISECONDS (not seconds!) // DateTimeOffset is the safest way to convert - it handles time zones correctly. // Always use ToUniversalTime() first to ensure we're working with UTC. var nowOffset = new DateTimeOffset(now.ToUniversalTime()); var yesterdayOffset = new DateTimeOffset(yesterday.ToUniversalTime()); // ToUnixTimeMilliseconds() returns milliseconds since 1970-01-01 00:00:00 UTC var nowMs = nowOffset.ToUnixTimeMilliseconds(); var yesterdayMs = yesterdayOffset.ToUnixTimeMilliseconds(); Console.WriteLine($"\nNow in milliseconds: {nowMs}"); Console.WriteLine($"Yesterday in milliseconds: {yesterdayMs}"); // IMPORTANT: Verify the conversion is reversible! // This catches off-by-one errors and timezone issues var nowConverted = DateTimeOffset.FromUnixTimeMilliseconds(nowMs); var yesterdayConverted = DateTimeOffset.FromUnixTimeMilliseconds(yesterdayMs); Console.WriteLine($"\nConverted back (should match above):"); Console.WriteLine($"Now: {nowConverted:O}"); Console.WriteLine($"Yesterday: {yesterdayConverted:O}"); // THE ACTUAL BUG: I found this timestamp in my application logs // Let's see what date it actually represents... var suspiciousTimestamp = 1763440087664L; var suspiciousDate = DateTimeOffset.FromUnixTimeMilliseconds(suspiciousTimestamp); Console.WriteLine($"\nSuspicious timestamp {suspiciousTimestamp} = {suspiciousDate:O}"); // Output showed this timestamp was in the year 2025... but it should have been in 2024! // Tracing back, I found I was using DateTime.Now instead of DateTime.UtcNow, // causing the local timezone offset to be applied incorrectly. ``` **बाहर आ गया:** इस स्क्रिप्ट से पता चला कि समय - समय पर समय - समय पर वक्‍त बीतता जा रहा है । `DateTime.Now` के बदले `DateTime.UtcNow` उत्पादन कोड में. 5 मिनट में स्थिर है बजाय डिबगिंग के संभावित 5 घंटे के. ### क्वैरी वाक्यांश तैयार किया जा रहा है **समस्या:** मुझे लगता है कि एक अनजाने में जांच करने की जरूरत है. `QueryHelpers` क्लास क्वैरी वाक्यांश निर्धारित करता है उममी एपीआई आशा रखता है. क्या यह यूआरएल यूआरएल- इन अक्षरों को फेंकता है? किस अनुक्रम में पैरामीटर हैं? **सी.एक्स?** दस्तावेज पढ़ना एक बात है, लेकिन असल आउटपुट आपको ठीक से बताता है कि आपका कोड क्या उत्पन्‍न करेगा. ```csharp #!/usr/bin/env dotnet-script // Pull in ASP.NET's WebUtilities package - this is the same package // that ASP.NET Core uses internally for query string manipulation #r "nuget: Microsoft.AspNetCore.WebUtilities, 9.0.0" using Microsoft.AspNetCore.WebUtilities; // These are the exact parameters I need to send to the Umami metrics API // Using a Dictionary makes it easy to see all parameters at once var queryParams = new Dictionary { {"startAt", "1730000000000"}, // Unix timestamp in milliseconds {"endAt", "1730086400000"}, // 24 hours later {"type", "url"}, // Type of metric to fetch {"unit", "day"}, // Aggregation unit {"limit", "500"} // Maximum results to return }; // QueryHelpers.AddQueryString builds a properly formatted query string // First parameter: base URL (empty string = just the query string portion) // Second parameter: dictionary of key-value pairs var queryString = QueryHelpers.AddQueryString(string.Empty, queryParams); Console.WriteLine($"Generated query string:"); Console.WriteLine(queryString); // Output: ?startAt=1730000000000&endAt=1730086400000&type=url&unit=day&limit=500 // Now let's verify we can parse it back - this catches encoding issues // that might not be obvious in the generated string Console.WriteLine($"\nParsed back (verifying round-trip):"); var parsed = QueryHelpers.ParseQuery(queryString); foreach (var kvp in parsed) { // Note: parsed values are StringValues, not string // StringValues can hold multiple values for the same key (e.g., ?tag=a&tag=b) Console.WriteLine($" {kvp.Key} = {kvp.Value}"); } // What I learned: QueryHelpers properly handles URL encoding for special characters // This became important when I later added search terms with spaces and unicode ``` ### जाँच HTTP एपीआई कॉल **समस्या:** इन्जेक्शन के साथ पूर्ण सेवा क्लास बनाने से पहले, त्रुटि संभालता, तर्क कोशिश करता है, और इकाई जाँच करता हूँ, मैं वास्तव में एपीआई वास्तव में काम करता है और इसके प्रतिक्रिया स्वरूप को जांचना चाहता था. **सी.एक्स?** यह 50 लाइन लिखने के लिए तेजी से तेजी से है sririririririum में उचित सेवा बनाने के लिए। यदि एपीआई मैं उम्मीद नहीं करता, तो मैं 5 घंटे के बजाय 5 मिनट बर्बाद कर दिया है। ```csharp #!/usr/bin/env dotnet-script // System.Net.Http.Json provides extension methods like PostAsJsonAsync and GetFromJsonAsync // This is the same package ASP.NET Core uses internally #r "nuget: System.Net.Http.Json, 9.0.0" using System.Net.Http.Json; using System.Text.Json; // Configuration - in a real app these would come from appsettings.json var websiteId = "32c2aa31-b1ac-44c0-b8f3-ff1f50403bee"; var umamiPath = "https://umami.mostlylucid.net"; var username = "admin"; // SECURITY: Never hardcode passwords! Use environment variables instead. // Set before running: $env:UMAMI_PASSWORD = "your-password" (PowerShell) // or: export UMAMI_PASSWORD="your-password" (bash) var password = Environment.GetEnvironmentVariable("UMAMI_PASSWORD") ?? ""; if (string.IsNullOrEmpty(password)) { // Provide helpful instructions when the password is missing Console.WriteLine("ERROR: Set UMAMI_PASSWORD environment variable"); Console.WriteLine(" PowerShell: $env:UMAMI_PASSWORD = 'your-password'"); Console.WriteLine(" Bash: export UMAMI_PASSWORD='your-password'"); return; // In CSX, 'return' at top level exits the script } // Create a single HttpClient instance - never create multiple instances in a loop! // BaseAddress means all subsequent requests can use relative URLs var httpClient = new HttpClient { BaseAddress = new Uri(umamiPath) }; // === STEP 1: Authenticate === // PostAsJsonAsync automatically serializes our anonymous object to JSON // and sets the Content-Type header to application/json Console.WriteLine("Step 1: Logging in..."); var loginPayload = new { username, password }; var loginResponse = await httpClient.PostAsJsonAsync("/api/auth/login", loginPayload); // Always check for errors before trying to read the response body if (!loginResponse.IsSuccessStatusCode) { Console.WriteLine($"Login failed: {loginResponse.StatusCode}"); var error = await loginResponse.Content.ReadAsStringAsync(); Console.WriteLine($"Error body: {error}"); return; } Console.WriteLine("Login successful!"); // === STEP 2: Extract JWT Token === // Use JsonDocument for one-off JSON parsing without creating dedicated DTOs // This is perfect for exploratory testing when we don't know the exact schema var loginContent = await loginResponse.Content.ReadAsStringAsync(); var loginJson = JsonDocument.Parse(loginContent); var token = loginJson.RootElement.GetProperty("token").GetString(); // Add the JWT token to all future requests via the Authorization header httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {token}"); // === STEP 3: Build the API Request === // Always use UTC for API calls to avoid timezone confusion var now = DateTime.UtcNow; var yesterday = now.AddHours(-24); var nowMs = ((DateTimeOffset)now).ToUnixTimeMilliseconds(); var yesterdayMs = ((DateTimeOffset)yesterday).ToUnixTimeMilliseconds(); var testUrl = $"/api/websites/{websiteId}/metrics?startAt={yesterdayMs}&endAt={nowMs}&type=url&unit=day&limit=10"; Console.WriteLine($"\nStep 2: Testing metrics endpoint..."); Console.WriteLine($"URL: {testUrl}"); // === STEP 4: Make the Request === var response = await httpClient.GetAsync(testUrl); Console.WriteLine($"Status: {response.StatusCode}"); // Pretty-print the JSON response so we can understand the structure var responseBody = await response.Content.ReadAsStringAsync(); try { var formatted = JsonSerializer.Serialize( JsonSerializer.Deserialize(responseBody), new JsonSerializerOptions { WriteIndented = true }); Console.WriteLine($"Response:\n{formatted}"); } catch { // If it's not valid JSON, just print raw Console.WriteLine($"Response (raw):\n{responseBody}"); } // What I learned from this script: // 1. The API returns an array of objects with 'x' (url) and 'y' (count) properties // 2. Empty results return [] not null // 3. The JWT token expires after 24 hours ``` ### डिपेंडेंसी के साथ जांच की जा रही है **समस्या:** मैंने एक Nuoc पैकेज (यूममी) प्रकाशित की है और इसे जाँचने के लिए वास्तव में एक उपभोक्ता का उपयोग करना चाहते हैं - यह उचित रूप से इलाज के साथ, नहीं सीधे रूप से तुरंत करने के द्वारा। **सी.एक्स?** एक जांच कंसोल परियोजना बना रही है, मेरे Nuo संदर्भ जोड़ रही है, कि सभी mucuticicicicic - कि समारोह के 15+ मिनट है. CSX के साथ, मैं उपभोक्ता अनुभव की जांच कर सकते हैं 2 मिनट के अंदर. ```csharp #!/usr/bin/env dotnet-script // Reference my published NuGet package - this tests the ACTUAL PUBLISHED VERSION, // not my local source code. This is crucial for verifying releases work correctly! #r "nuget: Umami.Net, 0.1.0" // Standard Microsoft DI packages - the same ones ASP.NET Core uses #r "nuget: Microsoft.Extensions.DependencyInjection, 9.0.0" #r "nuget: Microsoft.Extensions.Logging.Console, 9.0.0" using Umami.Net; using Umami.Net.UmamiData; using Umami.Net.UmamiData.Models.RequestObjects; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging; // Configuration var websiteId = "32c2aa31-b1ac-44c0-b8f3-ff1f50403bee"; var umamiPath = "https://umami.mostlylucid.net"; var password = Environment.GetEnvironmentVariable("UMAMI_PASSWORD") ?? ""; if (string.IsNullOrEmpty(password)) { Console.WriteLine("ERROR: Set UMAMI_PASSWORD environment variable"); return; } // === BUILD THE DI CONTAINER === // This mimics exactly what happens in a real ASP.NET Core app's Program.cs var services = new ServiceCollection(); // Add logging so we can see what the library is doing internally // Debug level will show HTTP requests, retries, token refreshes, etc. services.AddLogging(builder => { builder.AddConsole(); builder.SetMinimumLevel(LogLevel.Debug); // Show everything }); // This is my library's extension method - this is the public API that users call // I want to verify this works correctly without any hidden dependencies services.AddUmamiData(umamiPath, websiteId); // Build the container and resolve our service var serviceProvider = services.BuildServiceProvider(); var umamiDataService = serviceProvider.GetRequiredService(); Console.WriteLine("=== Testing Umami.Net Package via DI ===\n"); // === TEST THE LOGIN FLOW === Console.WriteLine("Testing login..."); var loginSuccess = await umamiDataService.LoginAsync("admin", password); if (!loginSuccess) { Console.WriteLine("ERROR: Login failed - check credentials"); return; } Console.WriteLine("Login successful!\n"); // === TEST THE METRICS API === Console.WriteLine("Testing metrics API..."); var metricsResult = await umamiDataService.GetMetrics(new MetricsRequest { StartAtDate = DateTime.UtcNow.AddHours(-24), EndAtDate = DateTime.UtcNow, Type = MetricType.url, // Get URL metrics (most visited pages) Unit = Unit.day, Limit = 10 }); // Display results Console.WriteLine($"API returned status: {metricsResult?.Status}"); if (metricsResult?.Data?.Length > 0) { Console.WriteLine($"\nTop {Math.Min(5, metricsResult.Data.Length)} URLs in the last 24 hours:"); foreach (var metric in metricsResult.Data.Take(5)) { // metric.x = the URL path, metric.y = the view count Console.WriteLine($" {metric.y,5} views - {metric.x}"); } } else { Console.WriteLine("No data returned - check date range or website ID"); } // What I verified with this script: // 1. The NuGet package installs correctly // 2. The DI registration extension method works // 3. The service can be resolved from the container // 4. Login and API calls work as expected ``` ### बैच वेक्टर डाटाबेस जांच किया जा रहा है **समस्या:** मैं एक Qudid वेक्टर डाटाबेस के लिए जांच कर रहा हूँ उत्पादन सेवा को लिखने से पहले, मुझे समझने की जरूरत है कि GPPC ग्राहक कैसे काम करता है, क्या GRPC ग्राहक की तरह लग रहा है, और मेरे स्थानीय क्यूकेट उदाहरण की जांच सही चल रहा है. **सी.एक्स?** सदिश डाटाबेस कई विकासकर्ताों के लिए नए क्षेत्र हैं. CSX मुझे प्रयोग करने देता है, विभिन्न ऑपरेशनों की कोशिश करता है और देखने के लिए तत्काल परिणाम. ```csharp #!/usr/bin/env dotnet-script // Qdrant.Client is the official .NET client for the Qdrant vector database #r "nuget: Qdrant.Client, 1.12.0" using Qdrant.Client; using Qdrant.Client.Grpc; // === CRITICAL: Windows gRPC HTTP/2 Fix === // By default, .NET on Windows doesn't allow unencrypted HTTP/2 connections (used by gRPC) // Without this line, you'll get cryptic "Protocol error" exceptions // This must be called BEFORE creating the QdrantClient! AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true); // Connect to Qdrant running locally // Note: Port 6334 is gRPC (faster), port 6333 is REST API // The .NET client uses gRPC for better performance var client = new QdrantClient("localhost", 6334); Console.WriteLine("=== Qdrant Vector Database Testing ===\n"); // === STEP 1: List Existing Collections === // A "collection" in Qdrant is like a table - it holds vectors with the same dimensionality Console.WriteLine("Step 1: Checking existing collections..."); var collections = await client.ListCollectionsAsync(); if (!collections.Any()) { Console.WriteLine("No collections found. This is a fresh Qdrant instance.\n"); } else { foreach (var collection in collections) { var info = await client.GetCollectionInfoAsync(collection); Console.WriteLine($" Collection: {collection}"); Console.WriteLine($" Points (vectors): {info.PointsCount}"); Console.WriteLine($" Status: {info.Status}"); } Console.WriteLine(); } // === STEP 2: Create a Test Collection === // Vector databases store "points" - each point has a vector and optional metadata (payload) var testCollection = "csx_demo"; Console.WriteLine($"Step 2: Creating test collection '{testCollection}'..."); try { await client.CreateCollectionAsync( collectionName: testCollection, vectorsConfig: new VectorParams { // Vector size MUST match your embedding model! // all-MiniLM-L6-v2 produces 384-dimensional vectors // text-embedding-ada-002 produces 1536-dimensional vectors Size = 384, // Cosine similarity is standard for text embeddings // Alternatives: Distance.Dot (dot product), Distance.Euclid (euclidean) Distance = Distance.Cosine }); Console.WriteLine("Collection created successfully!\n"); } catch (Exception ex) when (ex.Message.Contains("already exists")) { Console.WriteLine("Collection already exists, continuing...\n"); } // === STEP 3: Insert Test Data === // In production, vectors come from an embedding model (BERT, OpenAI, etc.) // For testing, we'll use random vectors Console.WriteLine("Step 3: Inserting test point..."); var testVector = Enumerable.Range(0, 384) .Select(_ => (float)Random.Shared.NextDouble()) .ToArray(); // Payload = metadata attached to the vector // This is what you filter on and return in search results var payload = new Dictionary { ["title"] = "Understanding Vector Databases", ["slug"] = "understanding-vector-databases", ["language"] = "en", ["created"] = DateTime.UtcNow.ToString("O") }; await client.UpsertAsync( collectionName: testCollection, points: new[] { new PointStruct { Id = Guid.NewGuid(), // Unique identifier for this point Vectors = testVector, Payload = { payload } } }); Console.WriteLine("Point inserted!\n"); // === STEP 4: Search for Similar Vectors === // In production, you'd embed a search query and find similar documents Console.WriteLine("Step 4: Searching for similar vectors..."); var searchVector = Enumerable.Range(0, 384) .Select(_ => (float)Random.Shared.NextDouble()) .ToArray(); var results = await client.SearchAsync( collectionName: testCollection, vector: searchVector, limit: 5, scoreThreshold: 0.0f // Return all results (random vectors won't have high similarity) ); Console.WriteLine($"Found {results.Count} results:"); foreach (var result in results) { // Score: 0 to 1 for cosine similarity (higher = more similar) Console.WriteLine($" Score: {result.Score:F4}"); Console.WriteLine($" Title: {result.Payload["title"].StringValue}"); Console.WriteLine($" Slug: {result.Payload["slug"].StringValue}"); } // === STEP 5: Clean Up === Console.WriteLine($"\nStep 5: Deleting test collection..."); await client.DeleteCollectionAsync(testCollection); Console.WriteLine("Done! Test collection cleaned up."); // What I learned from this script: // 1. The gRPC client is fast but needs the HTTP/2 switch on Windows // 2. Collection creation requires specifying vector dimensions upfront // 3. Payloads can be arbitrary key-value pairs // 4. Search returns results sorted by similarity score ``` ## और भी व्यावहारिक उदाहरण ### एचटीटीपी अंतपाइंट जाँच रहा है ```csharp #r "nuget: System.Net.Http.Json, 9.0.0" using System.Net.Http.Json; var http = new HttpClient(); http.DefaultRequestHeaders.Add("User-Agent", "CSX-Test"); // Test a GET endpoint var response = await http.GetFromJsonAsync( "https://api.github.com/repos/dotnet/runtime"); Console.WriteLine($"Stars: {response.GetProperty("stargazers_count")}"); Console.WriteLine($"Forks: {response.GetProperty("forks_count")}"); ``` ### JSON संशोधन जाँच की जा रही है ```csharp #r "nuget: System.Text.Json, 8.0.0" using System.Text.Json; using System.Text.Json.Serialization; public record Person( string Name, int Age, [property: JsonPropertyName("email_address")] string Email); var person = new Person("Scott", 50, "scott@example.com"); var options = new JsonSerializerOptions { WriteIndented = true, PropertyNamingPolicy = JsonNamingPolicy.CamelCase }; var json = JsonSerializer.Serialize(person, options); Console.WriteLine(json); // Deserialize back var parsed = JsonSerializer.Deserialize(json, options); Console.WriteLine($"Parsed: {parsed}"); ``` ### डाटाबेस क्वाटर जांच किया जा रहा है ```csharp #r "nuget: Npgsql, 8.0.0" #r "nuget: Dapper, 2.1.24" using Npgsql; using Dapper; var connectionString = "Host=localhost;Database=test;Username=postgres;Password=secret"; await using var conn = new NpgsqlConnection(connectionString); // Quick query test var results = await conn.QueryAsync( "SELECT * FROM users WHERE created_at > @date", new { date = DateTime.UtcNow.AddDays(-7) }); foreach (var row in results) { Console.WriteLine($"{row.id}: {row.name}"); } ``` ### रीएक्स पैटर्न जांच किया जा रहा है ```csharp using System.Text.RegularExpressions; var patterns = new[] { @"^\d{4}-\d{2}-\d{2}$", // Date @"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$", // Email @"^https?://[\w\-]+(\.[\w\-]+)+", // URL }; var testCases = new[] { "2025-11-24", "test@example.com", "https://mostlylucid.net", "not-a-date", "invalid-email", }; foreach (var test in testCases) { Console.WriteLine($"\n{test}:"); foreach (var pattern in patterns) { var match = Regex.IsMatch(test, pattern); if (match) Console.WriteLine($" ✓ Matches: {pattern}"); } } ``` ### LNINEQRegExp ```csharp var data = new[] { new { Name = "Alice", Age = 30, Department = "Engineering" }, new { Name = "Bob", Age = 25, Department = "Marketing" }, new { Name = "Charlie", Age = 35, Department = "Engineering" }, new { Name = "Diana", Age = 28, Department = "Engineering" }, }; // Test complex LINQ query var result = data .Where(x => x.Department == "Engineering") .GroupBy(x => x.Age >= 30) .Select(g => new { Senior = g.Key, Count = g.Count(), Names = string.Join(", ", g.Select(x => x.Name)) }); foreach (var group in result) { Console.WriteLine($"Senior: {group.Senior}, Count: {group.Count}, Names: {group.Names}"); } ``` ### बैच वेक्टर खोजQuery ```csharp #r "nuget: Qdrant.Client, 1.12.0" using Qdrant.Client; using Qdrant.Client.Grpc; var client = new QdrantClient("localhost", 6334); // Test collection exists var collections = await client.ListCollectionsAsync(); Console.WriteLine("Collections:"); foreach (var collection in collections) { Console.WriteLine($" - {collection}"); } // Test a search (assuming you have embeddings) var testVector = Enumerable.Range(0, 384).Select(_ => (float)Random.Shared.NextDouble()).ToArray(); try { var results = await client.SearchAsync( collectionName: "blog_posts", vector: testVector, limit: 5); foreach (var result in results) { Console.WriteLine($"Score: {result.Score}, Id: {result.Id}"); } } catch (Exception ex) { Console.WriteLine($"Search failed: {ex.Message}"); } ``` ## आईडीई समर्थन ### विजुडियो कोड संस्थापित करें [C# डेवी किट](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.csdevkit) एक्सटेंशन. आप पाते हैं: - वाक्य रचना हाइलाइटिंग - इंस्टेंसेन्स - कोड के द्वारा चलाएं/ डिबग करें बनाएँ `.vscode/launch.json`: ```json { "version": "0.2.0", "configurations": [ { "name": "Run CSX", "type": "coreclr", "request": "launch", "program": "dotnet", "args": ["script", "${file}"], "cwd": "${workspaceFolder}" } ] } ``` ### JetBEX सवार सवार ने सीएसएक्स समर्थन बनाया है. दायाँ क्लिक करें `.csx` फ़ाइल तथा चुनें " रन". ## युक्तियाँ और ईंटें ### दहेगा का प्रयोग करें लिनक्स/ लिंक पर स्क्रिप्ट को सीधे चलाने के लिए एक जावा स्क्रिप्ट जोड़ें: ```csharp #!/usr/bin/env dotnet-script Console.WriteLine("Runs directly with ./script.csx"); ``` ### तयशुदा से आर्गुमेंट्स वैश्विक द्वारा पहुँच कमांड लाइन तर्क `Args` चर: ```csharp // run: dotnet script test.csx -- arg1 arg2 "arg with spaces" Console.WriteLine($"Arguments: {Args.Count}"); foreach (var (arg, index) in Args.Select((a, i) => (a, i))) { Console.WriteLine($" [{index}]: {arg}"); } // Common pattern: use args with defaults var environment = Args.ElementAtOrDefault(0) ?? "development"; var verbose = Args.Contains("--verbose"); Console.WriteLine($"Environment: {environment}, Verbose: {verbose}"); ``` ### गुप्तों के लिए चर कभी भी हार्डकोड रहस्य - एनवायरनमेंट वेरिएबल: ```csharp var apiKey = Environment.GetEnvironmentVariable("API_KEY"); var dbPassword = Environment.GetEnvironmentVariable("DB_PASSWORD"); if (string.IsNullOrEmpty(apiKey)) { Console.Error.WriteLine("ERROR: API_KEY not set"); Console.Error.WriteLine("Run: $env:API_KEY='your-key' (PowerShell)"); Console.Error.WriteLine(" or: export API_KEY='your-key' (bash)"); Environment.Exit(1); } // Safely log partial key for debugging Console.WriteLine($"Using API key: {apiKey[..4]}...{apiKey[^4..]}"); ``` ### इंटरएक्टिव मोड ( जनक) खोज के लिए अंतर्क्रियात्मक सत्र प्रारंभ करें: ```bash dotnet script ``` आप एक सी # SPL: ``` > var x = 42; > x * 2 84 > #r "nuget: Newtonsoft.Json, 13.0.3" > using Newtonsoft.Json; > JsonConvert.SerializeObject(new { foo = "bar" }) "{"foo":"bar"}" ``` ### डिबगिंग VS कोड को a ब्रेकपाइंट को जोड़ने के द्वारा डिबग करें और F5, या: ```bash dotnet script test.csx --debug ``` ### त्वरित डीटीओ के लिए अभिलेखों का प्रयोग करें कोई क्लास फ़ाइलें आवश्यक नहीं - इनलाइन पारिभाषित नहीं: ```csharp // Records are perfect for CSX - single line definitions public record Person(string Name, int Age, string Email); public record ApiResponse(bool Success, T? Data, string? Error); public record SearchResult(string Title, string Slug, float Score); var person = new Person("Scott", 50, "scott@example.com"); var response = new ApiResponse(true, person, null); ``` ### डम्पकरण के साथ बहुत लंबा प्रिंट करें ```csharp #r "nuget: Dumpify, 0.6.5" using Dumpify; var data = new { Name = "Test", Items = new[] { 1, 2, 3 }, Nested = new { Foo = "bar" } }; data.Dump(); // Pretty console output with colors ``` ## सामान्य समस्या और मिल गया ### जारी: "Nooocs पैकेज नहीं मिला" पहली बार चलाने में धीमा - संकुल पृष्ठभूमि में डाउनलोड किया जा रहा है: ```csharp #r "nuget: SomePackage, 1.0.0" // First run: downloads // Second run: uses cache ``` **ठीक करें**: पूरा करने के लिए पहली बार चलाने के लिए इंतजार करें, या पूर्व- सूचना: ```bash dotnet script init # Creates omnisharp.json dotnet script # Downloads packages in REPL ``` ### जारी: "Type या नेमस्पेस नहीं मिला" पैकेज संस्करण गलत हो सकता है या असंगत है: ```csharp // Bad - version doesn't have the type you need #r "nuget: Microsoft.Extensions.Http, 6.0.0" // Good - use matching version for your .NET SDK #r "nuget: Microsoft.Extensions.Http, 9.0.0" ``` ### जारी रखें: विंडोज़ पर gRPC क्यूडंट तथा अन्य gRPC सेवाएँ HTTP/2 त्रुटियाँ के साथ असफल: ```csharp // Add this BEFORE creating gRPC clients AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true); var client = new QdrantClient("localhost", 6334); // Now works ``` ### जारी: मानने वाला सॉकेट STENDESESDENDESSD एक लूप में बहुत से दिल तंग उदाहरण नहीं बनाएँ: ```csharp // Bad - creates socket exhaustion foreach (var url in urls) { using var client = new HttpClient(); // DON'T do this await client.GetAsync(url); } // Good - reuse HttpClient using var client = new HttpClient(); foreach (var url in urls) { await client.GetAsync(url); } ``` ### जारी: ऊपरी स्तर पर सिंक ऊपरी स्तर-स्तर सिर्फ सीएसएक्स में काम करती है - कोई अतुल्यकालिक मुख्य आवश्यक नहीं: ```csharp // This works - no async Main needed var response = await httpClient.GetAsync("https://example.com"); var content = await response.Content.ReadAsStringAsync(); Console.WriteLine(content); ``` ### जारी: सम्मेलन लोड करता है परस्पर विरोधों का लोड करें जब स्थानीय डीएल का उल्लेख किया जाता है जो डिपेंडेंसीज़ रखता है: ```csharp // Order matters - load dependencies first #r "Mostlylucid.Shared/bin/Debug/net9.0/Mostlylucid.Shared.dll" #r "Mostlylucid.Services/bin/Debug/net9.0/Mostlylucid.Services.dll" // Or use NuGet for dependencies, local for your code #r "nuget: Microsoft.Extensions.Logging, 9.0.0" #r "MyLibrary/bin/Debug/net9.0/MyLibrary.dll" ``` ### जारी: स्क्रिप्ट संपादन के बाद नहीं चलेगा इंस्टेंसेंसिक कैश के लिए बासीपीव प्राप्त हो सकता है: ```bash # Clear the cache rm -rf ~/.dotnet-script/ # Linux/Mac rd /s /q %USERPROFILE%\.dotnet-script\ # Windows ``` ### जारी: नैटल संदर्भ प्रकार सीएसएक्स अलग-अलग डिफ़ॉल्ट उपयोग करता है - यदि आवश्यक हो: ```csharp #nullable enable string? nullableString = null; // OK string nonNullable = null; // Warning ``` ## CSX vs पूरा प्रोजेक्ट प्रयोग करने के लिए **जब आप चाहते हैं कि आपका मूल्य सुरक्षित रहे तो सीएसएक्स इस्तेमाल करें:** - क्विक- बन्द जांच - एपीआई खोजन - जीवन कहानी - प्रोजेक्ट में जोड़ने से पहले नुयू पैकेजेस की जाँच की जा रही है - गोपन कर रहे हैं, LINQ, JSON सीरियलीकरण - डाटाबेस क्वैरी जाँच - समझ/ लागू किया जा रहा है **जब पूर्ण परियोजना इस्तेमाल करें:** - कॉम्प्लेक्स डिपेंडेंसीज़ के साथ बहुत से फ़ाइल - इकाई जाँच ( xUn/NU पहले प्रयोग करें) - उत्पाद विडगेट कोड - टीम सहयोग - सीआई/सीडी फार्मेट्स ## वास्तविक विश्वव्यापी उदाहरण: मेरा ब्लॉग एपीआई जाँच कर रहा है यह एक स्क्रिप्ट है जिसे मैं सबसे अधिक खोज बिन्दुओं को जाँचने के लिए उपयोग करता हूँ: ```csharp #r "nuget: System.Net.Http.Json, 8.0.0" using System.Net.Http.Json; var baseUrl = Args.Length > 0 ? Args[0] : "https://www.mostlylucid.net"; var searchTerm = Args.Length > 1 ? Args[1] : "docker"; var http = new HttpClient { BaseAddress = new Uri(baseUrl) }; Console.WriteLine($"Searching {baseUrl} for '{searchTerm}'...\n"); var results = await http.GetFromJsonAsync( $"/api/search?term={Uri.EscapeDataString(searchTerm)}"); if (results.TryGetProperty("results", out var items)) { foreach (var item in items.EnumerateArray().Take(5)) { var title = item.GetProperty("title").GetString(); var slug = item.GetProperty("slug").GetString(); Console.WriteLine($"- {title}"); Console.WriteLine($" /{slug}\n"); } } ``` चलाएँ: ```bash dotnet script search-test.csx -- https://localhost:5001 "entity framework" ``` ## सारांश CSX स्क्रिप्ट सी # ROP और एक पूर्ण परियोजना के बीच सही मध्य भूमि हैं. वे के लिए आदर्श हैं: - **गति**: लिखें और सेकण्ड में चलाएँ - **सिमुलेटिकता**: कोई परियोजना समारोह नहीं - **पावर**: पूरा C# Nufo समर्थन के साथ - **पोर्टनेस**एक फ़ाइल साझा अगली बार जब आप C# में कुछ जल्दी परीक्षण की जरूरत है, छोड़ दें `dotnet new console` जिसमें (उन्होंने मुसलमानों के लिए) ईंधन झोंक रखा था `dotnet script` बजाय। **संसाधन:** - [डेकोनेट- स्क्रिप्ट GitName](https://github.com/dotnet-script/dotnet-script) - [C# स्क्रिप्टिंग दस्तावेज़ीकरण](https://docs.microsoft.com/en-us/archive/msdn-magazine/2016/january/essential-net-csharp-scripting)