.NET Tips | جستجوها: نتایج مشابه «سخنان بزرگان!»، صفحه: ۳۰

نظرات مطالب

بهبود کارآیی حلقه‌های foreach در دات نت 7

یک نکته‌ی تکمیلی: آشنایی با مفهوم «C# Lowering»

در این مطلب، جهت بررسی درک علت یکسان بودن کارآیی حلقه‌هایی که از دیدگاه ما یکی نیستند، از قابلیت نمایش #Low-level C استفاده شد که نام اصلی آن «C# Lowering» است. Lowering به معنای ترجمه‌ی امکانات سطح بالای یک زبان به امکانات سطح پایین آن است. یعنی حاصل عملیات صورت گرفته نیز باز به همان زبان اولیه است که نمونه‌ی آن، تبدیل یک حلقه‌ی foreach سطح بالا به نمونه‌ی سطح پایینی است که توسط NET Runtime. بهتر درک شده و ساده‌تر اجرا می‌شود.

مزایای Lowering

- بهبود کارآیی برنامه: برای مثال یکی از کارهایی که در این بین عموما انجام می‌شود «Loop unrolling» است. یعنی یک حلقه به چندین حلقه‌ی کوچکتر تقسیم می‌شود تا سربار instructions کنترلی حلقه کاهش پیدا کنند.

- طراحی ساده‌تر زبان: اینکار به تیم طراحی زبان امکان نوشتن کدهای اضافه‌تری را می‌دهد که کار برنامه نویس‌ها را کمتر می‌کند. برای مثال یک record واقعا چیزی نیست بجز یک کلاس پیاده سازی کننده‌ی IEquatable به صورت خودکار و در پشت صحنه.

Lowering چه زمانی رخ می‌دهد؟

Lowering جزئی از عملیات صورت گرفته‌ی در حین کامپایل است. زمانیکه دستور dotnet build را صادر می‌کنیم، ابتدا semantics & syntax analysis صورت می‌گیرد تا اگر برای مثال خطای دستوری وجود دارد، مشخص شود. سپس کدها به CIL یا Common intermediate language تبدیل می‌شوند. در حین این قسمت است که عملیات lowering نیز انجام می‌شود.

اگر علاقمند به مشاهده‌ی این کد #C ثانویه‌ی تولید شده‌ی توسط کامپایلر هستید، می‌توان از ابزار https://sharplab.io نیز استفاده کرد. برای مثال در سمت چپ آن کدهای زیر را قرار دهید:

using System;
using System.Collections.Generic;

var list = new List<int> { 1, 2 };

foreach(var item in list)
    Console.Write(item);

سپس در سمت راست آن، گزینه‌ی #Results C را انتخاب کنید تا بتوانید نمونه‌ی معادل تبدیل شده‌ی توسط کامپایلر را مشاهده نمائید.

‫۱ سال و ۸ ماه قبل، جمعه ۷ بهمن ۱۴۰۱، ساعت ۱۶:۰۲

کیانوش درتاج

مطالب

آموزش زبان Rust - قسمت 3 - متغیرها در زبان برنامه نویسی Rust

متغیرها، بخش اساسی برنامه نویسی هستند و به توسعه دهندگان اجازه می‌دهند، داده‌ها را در برنامه‌های خود ذخیره و دستکاری کنند. Rust که یک زبان برنامه نویسی سیستم‌های مدرن است، دارای مجموعه‌ای غنی از ویژگی‌ها برای کار با متغیرها می‌باشد. در این آموزش به بررسی ایجاد، تغییرپذیری و Scope متغیرها در Rust و همچنین مفهوم Shadow می‌پردازیم.

ایجاد متغیرها در Rust

در Rust، متغیرها را می‌توان با استفاده از کلمه کلیدی let و به دنبال آن، نام متغیر و مقدار اختصاص داده شده‌ی به آن ایجاد کرد. مثلا:

let x = 10;

این یک متغیر به نام x را با مقدار 10 ایجاد می‌کند. Rust یک زبان استاتیکی است؛ به این معنا که متغیرها باید با نوع خود در زمان ایجاد، اعلان کنند. مثلا:

let x: i32 = 10;

این یک متغیر به نام x را با نوع i32 (یک عدد صحیح امضاء شده‌ی 32 بیتی) و مقدار 10 ایجاد می‌کند.

متغیرهای تغییرپذیر (Mutable) و تغییرناپذیر (Immutable) در Rust

در Rust، متغیرها به طور پیش فرض تغییر ناپذیر هستند؛ به این معنا که پس از تخصیص، مقدار آنها قابل تغییر نیست؛ مثلا:

let x = 10;
x = 20; //compile-time error

برای ایجاد یک متغیر قابل تغییر در Rust، از کلمه کلیدی mut استفاده می‌شود:

let mut x = 10;
x = 20;

متغیرهای تغییرناپذیر در Rust مفید هستند زیرا می‌توانند به جلوگیری از خطاهای ناشی از تغییرات ناخواسته‌ی در داده‌ها کمک کنند. متغیرهای قابل تغییر، برای زمانیکه داده‌ها نیاز به اصلاح دارند، مانند یک حلقه، مفید هستند.

Scope متغیرها در Rust

متغیرها در Rust دارای دامنه خاصی هستند که توسط curly braces که بیانیه آنها را احاطه کرده‌اند، تعریف می‌شود. مثلا

{
   let x = 10;
} // این متغیر خارج از این محدوده در دسترس نخواهد بود

در Rust، متغیرهایی که خارج از یک تابع یا بلوک، با استفاده از کلمه‌ی کلیدی static اعلام می‌شوند، global scope هستند و از هر نقطه‌ای در برنامه قابل دسترسی هستند. با این حال، متغیرهای global در Rust با ملاحظاتی همراه هستند. از آنجائیکه می‌توان به آنها از هر جایی در برنامه دسترسی داشت، ردیابی مکان و زمان تغییر متغیر ممکن است دشوار باشد که می‌تواند رفتار برنامه را چالش برانگیز کند. این امر به ویژه در برنامه‌های بزرگتر که ممکن است متغیرهای زیادی در آن در حال استفاده باشند، صادق است. علاوه بر این، استفاده از متغیرهای global می‌تواند آزمایش و اشکال‌زدایی کد را سخت‌تر کند؛ زیرا وضعیت آنها می‌تواند توسط هر بخشی از برنامه تغییر کند.

به این دلایل، به طور کلی توصیه می‌شود که از متغیرهای global به مقدار کم در Rust استفاده کنید. در عوض، اغلب بهتر است از متغیرهایی استفاده شود که در تابع یا بلوکی که در آن مورد استفاده قرار می‌گیرند، تعریف و scope شده‌اند. این مورد می‌تواند درک رفتار برنامه را آسان‌تر کند و از عوارض جانبی ناخواسته ناشی از متغیرهای سراسری جلوگیری کند.

Shadowing Variables in Rust

Shadowing یک مفهوم برنامه نویسی است که به شما امکان می‌دهد یک متغیر را در یک scope، دوبار اعلام کنید و به طور موثر متغیر اصلی را با متغیر جدیدی به همین نام shadow کنید. وقتی متغیری را shadow میکنید، متغیر جدید، متغیر قبلی را در scope داخلی، "shadow" می‌کند و هر ارجاعی به این متغیر در آن محدوده، به متغیر جدید اشاره می‌کند.

fn main() {
    let x = 5;
    println!("The value of x is: {}", x); // خروجی برابر 5 است

    let x = "hello";
    println!("The value of x is: {}", x); // خروجی برابر hello
}

در این کد، متغیر x دوبار با مقادیر مختلف اعلان می‌شود؛ اما اعلان دوم، دوباره از کلمه‌ی کلیدی let استفاده می‌کند و عملاً متغیر اول را shadow می‌اندازد. این یعنی println دوم، مقدار متغیر دوم را که یک رشته است، به جای متغیر اول که یک عدد صحیح است، خروجی می‌دهد.
سایه زدن زمانی می‌تواند مفید باشد که بخواهید مقدار، یا نوع یک متغیر را در یک scope، بدون اینکه نام آن را تغییر دهید. همچنین می‌تواند کد را با استفاده‌ی مجدد از یک نام متغیر، برای اهداف مختلف خواناتر کند. با این حال، همچنین می‌تواند کد را پیچیده‌تر و درک آن را سخت‌تر کند؛ بنابراین باید با دقت و با دلیل موجه از آن استفاده کنید .

‫۱ سال و ۶ ماه قبل، چهارشنبه ۲ فروردین ۱۴۰۲، ساعت ۱۷:۱۰

میثم ثوامری

اشتراک‌ها

آیا VB.NET مرده است؟

13 سپتامر روز برنامه نویس بوده روز مهاجرت برنامه نویسان VB.NET به #C.قابل توجه برنامه نویسان VB.NET مایکروسافت تا June 30, 2017 از VB.NET پشتیبانی میکنه.

‫۱۱ سال و ۱۲ ماه قبل، پنجشنبه ۴ آبان ۱۳۹۱، ساعت ۱۴:۴۲

بهمن خلفی

نظرات نظرسنجی‌ها

در محیط برنامه نویسی از دارک مود استفاده می کنید یا لایت مود؟

درود به همه دوستان و با احترام به همه نظرات

بنده تقریبا از زمانی که dark mode در دسترس قرار گرفت از این حالت تیره استفاده میکنم ، خوب قبلا از محیط روشن light mode استفاده میکردم تجربیاتی که داشتم رو ذکر میکنم :

به دلیل کار بیش از 10 ساعت روزانه ، با توجه به اینکه مشکل بینایی نداشتم ولی حالت روشن باعث عصبی بودن و بیخوابی مزمن شده بود با تغییر محیط به حالت تیره تاثیر بسیار زیادی در کیفیت خواب داشتم بصورتی که این موضوع کاملا محسوس بود.
از طرفی کار با 2 یا 3 مانیتور با حالت روشن ، نیاز به دقت بیشتری دارد و خستگی زیادی رو به چشم تحمیل میکند و مدت زمان کمتری با دقت بالا میتونستم کار کنم و تمرکزم به دلیل صفحه سفید کمتر بود.
اگر محیط نور مناسب و ملایمی داشته باشد و از پشت سر باشد حالت روشن خستگی کمتری خواهد داشت و چشم رو کمتر اذیت میکنه ولی در حالت تیره خستگی چشم خیلی کمتر خواهد بود و تداخل رنگی کمتری داریم.
برای برنامه نویسی بلند مدت ، حالت تیره و برای طراحی گرافیک و کار با تصاویر حالت روشن (به دلیل وضوح مناسب ) بیشتر توصیه میکنم .

مشاغل مشابه برنامه نویسی و کار با کامپیوتر به دلیل عدم تحرک کافی بدن و پشت میز نشینی آسیبهای زیادی را وارد میکند اما در هر صورت به نظرم هر کسی قبل از انتخاب محیط کاری خود باید با یک چشم پزشک آشنا به تکنولوژی و شغل مورد نظر ، مشاوره کند تا بتواند از محیط شغلی خودش کمتر آسیب ببیند.

‫۱ سال و ۵ ماه قبل، دوشنبه ۱۴ فروردین ۱۴۰۲، ساعت ۰۴:۴۹

آرش خوشبخت

مطالب

Microsoft Test Manager - قسمت اول

مقدمه:

مدیریت آزمون مایکروسافت یا Microsoft Test Manager یک ابزار تست نویسی است که به تستر‌ها این اجازه را می‌دهد تا بتوانند برای UI برنامه‌های خود یا sprint‌های پروژه خود تست بنویسند. این ابزار برای نوشتن آزمون‌های پیشرفته و مجتمع سازی مدیریت طرح‌های تست یا test plans همراه با موردهای تست یا test case در طول توسعه برنامه است. یکی از مزایایی که این ابزار دارد این است که در طول انجام تست می‌توانید اشکالات تست را ثبت کنید و هم چنین می‌توانید شرحی در مورد انجام تست یا اشکالی که در آن تست وجود دارد، ثبت کنید. همچنین می‌توانید گزارشی از تست هایی که انجام داده اید و پاس شدن یا پاس نشدن تست‌ها و تاریخ انجام آن‌ها را نیز مشاهده کنید. قبل از کار با نرم افزار MTM باید یک سری مطالب مهم را در مورد انجام تست و مفهوم Agile بدانیم.

استراتژی تست:

زمانی که شما تست Agile را معرفی می‌کنید تیم برنامه نویسی شما می‌تواند بر روی تست‌های شما هم در سطح sprint و هم در سطح پروژه تمرکز کنند. تست در سطح sprint شامل تست هایی می‌شود که همه user story‌ها در بر بگیرد یعنی در واقع همان تست‌های واحد شما می‌شود. در سطح پروژه هم شامل تست هایی می‌شود که چندین sprint را در بر می‌گیرد که در واقع می‌توان تست‌های integrated گفت. بهتر است زمانی که تیم برنامه نویسی کدنویسی می‌کنند شما طرح تست‌های خود را بسازید و برای انجام تست کاملا آماده باشید. این تست‌ها شامل تست واحد، تست performance، تست امنیتی و تست usability و غیره می‌باشد.

برای آماده کردن تست Agile در ابتدا شما باید یک تاریخچه یا history از برنامه یا سیستم خود داشته باشید. شما می‌توانید با استفاده از Microsoft Test Manager طرح تست خود را برای هر یک از sprint‌های پروژتان بسازید و موردهای تست را مشخص کنید.

سپس باید کدهایی که برنامه نویسان می‌نویسند قابلیت تست را داشته باشند و شما به عنوان یک تستر باید آشنایی کاملی از ساختار و الگوهای برنامه تان داشته باشید.

تست یک فرآیند تکراری می‌باشد که همزمان با اجرای پروژه تان صورت می‌گیرد در زیر می‌توانید فرآیند کار تست و انجام کدنویسی را مشاهده نمایید:

Test Planning:

Test Planning فرآیندی است که به تیم شما کمک می‌کند تا درک درستی از پروژه داشته باشند و همچنین تیم را برای انجام هر گونه تستی آماده کند. تست Agile در سطح Sprint انجام می‌شود که در هر Sprint تیم شما تست هایی را ایجاد می‌کنند تا user story هایی که در هر Sprint وجود دارد، مورد بررسی قرار گیرند. در شکل زیر قالبی از test plan‌های شما در یک پروژه را نمایش می‌دهد:

البته این قالب‌ها بر اساس سلیقه شخصی است اما در کل می‌توانیم قالب تست را به صورت بالا در نظر بگیریم.

همیشه باید این را در نظر داشته باشیم که در طول هر sprint حتما باید تست‌ها را اجرا کرده و در صورت وجود خطا، آن خطا را رفع کنیم تا در مراحل بالاتر با مشکلی مواجه نشویم. در قسمت بعد با Microsoft Test Manager و روش‌های نوشتن sprint و تست‌ها آشنا خواهیم شد.

‫۱۱ سال و ۶ ماه قبل، یکشنبه ۱ اردیبهشت ۱۳۹۲، ساعت ۰۴:۲۵

پرهام دستغیب

مطالب

پشتیبانی از انقیاد پویا در سی‌شارپ

زبان سی‌شارپ strongly typed و type safe است. کامپایلر بیشتر کد را از نظر صحت نوع (Type) بررسی میکند و در صورت بروز خطا، روند کامپایل متوقف خواهد شد. با این وجود سی‌شارپ اجازه میدهد که کدهای داینامیک نیز داشته باشیم؛ کدهایی که در زمان کامپایل برای کامپایلر ناشناس هستند و اگر خطای نوع در آنها وجود داشته باشد، در زمان اجرا مشخص شده و باعث توقف برنامه میشود.

Type Safety

ایمنی نوع، قاعده‌ای است در زبانهای برنامه‌نویسی که اجازه نمیدهد متغیرها، مقادیری را دریافت کنند که متفاوت با نوع تعریف شده‌ی آنها باشد. اگر این بررسی وجود نداشت، در زمان اجرا مقادیر خوانده شده از حافظه باعث رفتاری غیر قابل پیش‌بینی میشد؛ مثلا در یک متغیر عددی، مقدار رشته‌ای ذخیره و در زمان اجرا با یک مقدار عددی دیگر جمع بسته و نمایش داده شود. کامپایلر همچنین بررسی اعضای اعلان نشده‌ی متغیرها را نیز انجام میدهد که در قطعه کد زیر آمده‌است:

string text = “String value”;
int textLength = text.Length;
int textMonth = text.Month; // won’t compile

با این حال ایمنی نوع در سی‌شارپ کاملا قابل اعتماد نیست و میشود به روشی آن را دور زد!

public interface IGeometricShape
{
     double Circumference { get; }
     double Area { get; }
}
public class Square : IGeometricShape
{
     public double Side { get; set; }
     public double Circumference => 4 * Side;
     public double Area => Side * Side;
}
public class Circle : IGeometricShape
{
     public double Radius { get; set; }
     public double Circumference => 2 * Math.PI * Radius;
     public double Area => Math.PI * Radius * Radius;
}

IGeometricShape circle = new Circle { Radius = 1 };
Square square = ((Square)circle); // no compiler error
var side = square.Side;

در خط کدی که با کامنت مشخص شده، هر چند که دیده میشود نوع circle نمیتواند به نوع square تبدیل شود، اما این کد بدون خطا کامپایل و خطای InvalidCastException در زمان اجرا رخ خواهد داد. به دلیل اینکه هر دو نوع circle و square از نوع پایه IGeometricShape هستند، کامپایلر خطایی نخواهد گرفت؛ اما در زمان اجرا و زمانیکه برنامه میخواهد اجزاء circle را به square تبدیل کند، مشخص میشود که امکان تبدیل کامل circle به square نیست و خطا رخ خواهد داد.

Dynamic Binding

توسط انقیاد پویا در سی‌شارپ، کامپایلر بررسی نوع را در زمان کامپایل انجام نخواهد داد. کامپایلر فرض را بر این میگیرد که کد معتبر است و تمام متغیرها به درستی قابل دسترسی هستند. بررسی‌ها در زمان اجرا خواهند بود و زمانی خطا رخ خواهد داد که مثلا دسترسی به یک عضو از یک متغیر امکانپذیر نباشد؛ به این دلیل که آن عضو برای آن نوع وجود ندارد.

توسط کلمه کلیدی dynamic میتوان متغیرهایی را تعریف کرد که در زمان کامپایل از نظر نوع بررسی نشوند؛ مانند مثال زیر.

dynamic text = “String value”;
int textLength = text.Length;
int textMonth = text.Month; // throws exception at runtime

واضح است که مثال بالا بی‌فایده است؛ اولا خطا در زمان کامپایل مشخص نمیشود و ثانیا مدیریت خطا در زمان اجرا بر کارآیی برنامه تاثیر خواهد داشت. روش دیگر استفاده از dynamic که کارآیی پایینی دارد در مثال زیر آمده.

public dynamic GetAnonymousType()
{
  return new
    {
        Name = “John”,
        Surname = “Doe”,
        Age = 42
    };
}

dynamic value = GetAnonymousType();
Console.WriteLine($”{value.Name} {value.Surname}, {value.Age}”);

در مثال بالا نوع بازگشتی متد و متغیری که برای نگهداری نوع بازگشتی تعریف شده از نوع dynamic هستند. هر چند که در زمان کامپایل میشود هر مقداری و نوعی را از متد بازگشت داد، اما مانند مثال قبل، تا زمان اجرا، صحت اینکه آیا واقعا چنین نوعی جهت بازگشت وجود دارد یا نه و همچنین اساسا نوع بازگشت داده شده قابل استفاده و تبدیل هست یا نه، بررسی نخواهد شد. مضاف بر این مشکلات، IntelliSense نخواهیم داشت و اگر بخواهیم از یک اسمبلی دیگر به متد بالا دسترسی پیدا کنیم با خطای RuntimeBinderException مواجه خواهیم شد؛ علت این است که نوع‌های anonymous به صورت internal اعلان می‌شوند. اما میشود استفاده‌های بهتری از نوع dynamic داشت؛ برای مثال زمان استفاده از کتابخانه‌ی JSON.NET که نمونه‌ای از آن در زیر آمده.

string json = @"
{
     ""name"": ""John"",
     ""surname"": ""Doe"",
     ""age"": 42
}";

dynamic value = JObject.Parse(json);
Console.WriteLine($"{ value.name} { value.surname}, { value.age}");

مانند نوع anonymous در مثال قبل، متد Parse میتواند مقادیر را به صورت پویا برگشت دهد و میتوان از این مقادیر مانند خصوصیات شیء ایجاد شده، از JSON استفاده کرد، بدون آنکه کامپایلر از وجود آنها اطلاعی داشته باشد. به این ترتیب در زمان اجرا میشود اشیاء JSON را به برنامه داد و از مقادیر آن مانند دسترسی به یک property استفاده کرد؛ کاری که نمیشود با نوعهای anonymous که در مثال بالاتر آورده شد انجام داد. برای حل این مسئله میتوان از دو شیء کمکی در کتابخانه NET Framework. استفاده کرد.

ExpandoObject

بین این دو شیء، ExpandoObject ساده‌تر است. به همراه کلمه کلیدی dynamic، این شیء اجازه میدهد که به نوع ساخته شده از آن در زمان اجرا و به صورت پویا، عضوی اضافه یا حذف کنیم؛ این اعضا میتوانند متد هم باشند.

dynamic person = new ExpandoObject();
person.Name = "John";
person.Surname = "Doe";
person.Age = 42;
person.ToString = (Func<string>)(() => $”{person.Name} {person.Surname}, {person. Age}”);

Console.WriteLine($"{ person.Name}{ person.Surname}, { person.Age}");

برای اینکه ببینیم در زمان اجرا چه اعضایی به این شی اضافه شده، می‌توان نمونه ساخته شده از آن را به نوع <IDictionary<string, object تبدیل و در یک حلقه به آنها دسترسی پیدا کرد. از همین طریق هم میشود عضوی را حذف کرد.

var dictionary = (IDictionary<string, object>)person;
foreach (var member in dictionary)
{
     Console.WriteLine($”{member.Key} = {member.Value}”);
}
dictionary.Remove(“ToString”);

DynamicObject

از آنجایی که ExpandoObject برای سناریو‌های ساده کاربرد دارد و کنترل کمتری بر روی اعضا و نمونه‌های ایجاد شده‌ی توسط آن داریم، می‌توان از شیء DynamicObject استفاده کرد؛ البته نیاز به کدنویسی بیشتری دارد. پیاده‌سازی اعضا برای شیء DynamicObject در یک کلاس صورت میگیرد که در زیر آورده شده‌است:

class MyDynamicObject : DynamicObject
{
       private readonly Dictionary<string, object> members = new Dictionary<string, object>();

       public override bool TryGetMember(GetMemberBinder binder, out object result)
       {
              if (members.ContainsKey(binder.Name))
              {
                  result = members[binder.Name];
                  return true;
              }
              else
              {
                  result = null;
                  return false;
             }
       }

      public override bool TrySetMember(SetMemberBinder binder, object value)
      {
               members[binder.Name] = value;
              return true;
      }

      public bool RemoveMember(string name)
      {
            return members.Remove(name);
      }

}

dynamic person = new MyDynamicObject();
person.Name = “John”;
person.Surname = “Doe”;
person.Age = 42;
person.AsString = (Func<string>)(() => $”{person.Name} {person.Surname}, {person.
Age}”);

یک نکته در قطعه کد بالا وجود دارد. در شیء ExpandoObject، متد ToString را اضافه کردیم، اما برای شیء DynamicObject نام آن را تغییر داده و مثلا AsString گذاشتیم. اگر از نام ToString استفاده میکردیم در زمان فراخوانی، متد پیش‌فرض کلاس DynamicObject فراخوانی میشد. DynamicObject زمانی یک عضو پویا را فراخوانی میکند که آن عضو جدید از قبل وجود نداشته باشد. از آنجا که خود کلاس، متد ToString را دارد متد TryGetMember برای فراخوانی کردن آن اجرا نخواهد شد.

‫۶ سال و ۳ ماه قبل، جمعه ۲۲ تیر ۱۳۹۷، ساعت ۰۰:۲۵

وحید نصیری

نظرات مطالب

بهبود صفحه‌‌ی بارگذاری اولیه در Blazor WASM

نمایش درصد بارگذاری اولیه‌ی یک برنامه‌ی Blazor WASM در دات نت 7

اگر یک برنامه‌ی جدید blazor wasm را در دات نت 7، برای مثال با دستور dotnet new blazorwasm --hosted ایجاد کنیم، با اجرای آن، یک progress-bar حلقوی نمایش میزان درصد بارگذاری اولیه‌ی برنامه ظاهر می‌شود که به نوعی پیاده سازی توکار نکات مطلب جاری است. این پیاده سازی از اجزای زیر تشکیل شده‌است:
الف) تغییرات فایل index.html برنامه
برای این منظور، فایل Client\wwwroot\index.html به صورت زیر تغییر کرده‌است:

<body>
    <div id="app">
        <svg class="loading-progress">
            <circle r="40%" cx="50%" cy="50%" />
            <circle r="40%" cx="50%" cy="50%" />
        </svg>
        <div class="loading-progress-text"></div>
    </div>

که در اینجا progress-bar حلقوی را با یک طرح SVG ایجاد کرده‌اند.

ب) تغییرات فایل app.css برنامه
کلاس‌های progress-bar را به این صورت در فایل Client\wwwroot\css\app.css اضافه کرده‌اند:

.loading-progress {
    position: relative;
    display: block;
    width: 8rem;
    height: 8rem;
    margin: 20vh auto 1rem auto;
}
    .loading-progress circle {
        fill: none;
        stroke: #e0e0e0;
        stroke-width: 0.6rem;
        transform-origin: 50% 50%;
        transform: rotate(-90deg);
    }
        .loading-progress circle:last-child {
            stroke: #1b6ec2;
            stroke-dasharray: calc(3.141 * var(--blazor-load-percentage, 0%) * 0.8), 500%;
            transition: stroke-dasharray 0.05s ease-in-out;
        }
.loading-progress-text {
    position: absolute;
    text-align: center;
    font-weight: bold;
    inset: calc(20vh + 3.25rem) 0 auto 0.2rem;
}
    .loading-progress-text:after {
        content: var(--blazor-load-percentage-text, "Loading");
    }

روش سفارشی سازی این progress-bar بر اساس دو CSS variable فوق صورت می‌گیرد:
--blazor-load-percentage: درصد بارگذاری جاری را مقدار دهی می‌کند.
--blazor-load-percentage-text: متن Loading نمایش داده شده را مشخص می‌کند.

برای مثال اگر علاقمند باشیم بجای SVG پیش‌فرض از progress-bar توکار خود فریم‌ورک بوت‌استرپ استفاده کنیم، روش کار به صورت زیر خواهد بود:

<body>
    <div id="app">
      <div class="progress">
        <div class="progress-bar progress-bar-striped progress-bar-animated" 
            role="progressbar" aria-valuenow="75" aria-valuemin="0" aria-valuemax="100" 
            style="width: var(--blazor-load-percentage, 0%)">
            <div class="loading-text"></div>
        </div>        
      </div>

که در اینجا همان CSS variable معادل درصد بارگذاری، بجای width استفاده شده تا به صورت خودکار سبب پیشرفت progress-bar شود. همچنین کلاس جدید loading-text را هم همانند loading-progress-text:after موجود به صورت زیر به فایل app.css اضافه می‌کنیم تا سبب نمایش متن درصد پیشرفت جاری نیز شود:

.loading-text:after {
        content: var(--blazor-load-percentage-text, "Loading");
    }

‫۱ سال و ۶ ماه قبل، دوشنبه ۸ اسفند ۱۴۰۱، ساعت ۱۸:۴۷

عیدی مراد

نظرسنجی‌ها

بعنوان مدیر تیم نرم افزاری با تعداد متوسط (6-7 نفر) با متدولوژی اسکرام، کدام روش را بیشتر می پسندید و استفاده می کنید؟

تقسیم کار بصورت وظیفه‌ای و سپردن یک قسمت از منطق برنامه به یک نفر و پیاده سازی همه لایه ها توسط او
اعضاء با تخصص‌های خاص و تقسیم افراد بین لایه‌ها (برنامه نویس backend،برنامه نویس ui و ...)
روش ترکیبی و سفارشی شده (لطفا در نظرات توضیح دهید)

‫۹ سال و ۱ ماه قبل، پنجشنبه ۲۶ شهریور ۱۳۹۴، ساعت ۰۳:۴۲

کیانوش درتاج

مطالب

آموزش زبان Rust - قسمت 10 - مفهوم Borrowing در Rust

Rust، یک زبان برنامه نویسی سیستمی است که برای ایمنی، همزمانی و عملکرد بهتر طراحی شده‌است. یکی از ویژگی‌های کلیدی آن، مفهوم Borrowing است که به توسعه دهندگان اجازه می‌دهد تا ارجاعاتی را به ارزش‌ها بدون در اختیار گرفتن مالکیت، ایجاد کنند. این مقاله اهمیت قرض گرفتن را در این زبان برنامه‌نویسی را بررسی می‌کند.

Borrowing در Rust

Borrowing عمل ایجاد ارجاع به یک ارزش، بدون در اختیار گرفتن مالکیت است. در Rust، ارجاعات، مشابه اشاره‌گرهای معمولی هستند؛ اما با قوانین و محدودیت‌هایی اضافه شده‌اند. ویژگی‌های اصلی Borrowing عبارتند از:

References اشاره‌گرهایی با قوانین و محدودیت‌ها هستند.
References مالکیت ارزش‌ها را نمی‌گیرند.

دلایل Borrowing در Rust

چندین دلیل وجود دارند که چرا Borrowing در Rust سودمند است:
Performance : به کمک Borrowing، با انتقال ارجاع به یک مقدار بجای clone، عملکرد بهبود بخشیده می‌شود. به عنوان مثال هنگامیکه یک تابع، دارای پارامتری مانند یک رشته است، انتقال مرجع، کارآمدتر از تکرار مقدار است.
Ownership Management : در مواردی که مالکیت، مورد نیاز یا مطلوب نیست، Borrowing یک راه حل ایده‌آل است. با عدم مالکیت، یک تابع نباید مسئول تصمیم‌گیری در مورد زمان پاکسازی یک مقدار باشد.

قوانین Borrowing در Rust

Rust دو قانون اصلی Borrowing را اعمال می‌کند:

در هر زمان معین، می‌توانید یک مرجع قابل تغییر یا هر تعداد مرجع تغییرناپذیر داشته باشید.
مراجع باید همیشه معتبر باشند.

این قوانین به حل دو مشکل عمده در برنامه نویسی کمک می‌کنند:
Data Races : مشکل Data Races زمانی رخ می‌دهد که دو رشته سعی می‌کنند مکان حافظه‌ی یکسانی را به طور همزمان بخوانند و یا بنویسند که منجر به نتایج غیر قطعی می‌شود. قوانین Borrowing در Rust تضمین می‌کند که از چنین درگیری‌هایی جلوگیری می‌شود.
Dangling References : یک dangling reference به حافظه‌ی نامعتبری اشاره می‌کند. با اطمینان از اینکه مراجع همیشه معتبر هستند، قوانین وام گیری Rust از وقوع ارجاعات آویزان جلوگیری می‌کند.

ویژگی‌های قابل توجه Borrowing

Immutable References by Default : در Rust، یک reference به طور پیش فرض تغییر ناپذیر است. این انتخاب طراحی بر اهمیت Borrowing برای برنامه نویسی ایمن و کارآمد تاکید دارد.
Automatic Dereferencing: در Rust ویژگی عدم ارجاع خودکار وجود دارد؛ به این معنا که توسعه دهندگان مجبور نیستند به صراحت، ارجاع را پیاده سازی کنند. این روند، کار با ارزش‌های borrowed را ساده می‌کند.

Rust یک زبان برنامه نویسی قدرتمند است که ایمنی و عملکرد را از طریق ویژگی‌هایی مانند Borrowing در اولویت قرار می‌دهد. با درک مفهوم Borrowing و رعایت قوانین آن، توسعه دهندگان می‌توانند از پتانسیل کامل Rust برای ایجاد نرم افزاری کارآمد، قابل اعتماد و همزمان استفاده کنند.

‫۱ سال و ۵ ماه قبل، یکشنبه ۲۰ فروردین ۱۴۰۲، ساعت ۰۳:۴۵

مهمان

نظرات مطالب

بررسی علت CPU Usage بالای برنامه در حال اجرا

ممنون آقای نصیری
از کجا میشه درصد استفاده از CPU رو متوجه شد؟ وقتی CPU Usage ما به 100 درصد میرسه نه میشه به سرور کانکت شد و نه اینکه وقتی کانکتیم میذاره برنامه ای رو اجرا کنیم. بخاطر همین مجبوریم وقنی درصد از حدی بالاتر رفت بلافاصله یه سری اطلاعات را ثبت کنیم.

‫۱۳ سال و ۴ ماه قبل، شنبه ۱ مرداد ۱۳۹۰، ساعت ۱۳:۰۱