FirstName

firstName

strFirstName
lblFirstName

<Company>.<Technology|Produt|Project>[.<Feature>][.<SubNamespace>]

Microsoft.Reporting.WebForms
Kara.Support.Manager.Enums
Kara.CSS.HQ.WebUI.Configuration

PackageManager , PacakgeConfigGenerator
Circle , Utility , Package

CreateConfig , classdata
CManager , ClsPackage , Config_Creator , Config1389

CenterCollection , PackageCollection

public delegate void Logger (string log);
public delegate void LoggingCallback (object sender, string reason);

AddEventArgs , EditEventArgs , DeleteEventArgs

Adding , Add , Added

public delegate void <EventName>EventHandler  (object sender, <EventName>EventArgs e);

public event EventHandler <AddEventArgs> Adding;

DisplayNameAttribute , MessageTypeAttribute

IComponent  (اسم)
IConnectionProvider (موصوف)
ICloneable (صفت)

public enum FileMode {
    Append,
    Read, …
}

[Flag]
public enum KeyModifiers {
    Alt = 1, 
    Control = 2,
    Shift = 4
}

public enum OperationState {
    DoneState, 
    FaultState,
    RollbackState
}

AddDays , Save , DeleteRow , BindData , Close , Open

Radius , ReportType , DataSource , Mode , CurrentCenterId

public CenterCollection Centers { get; set; }

if (list.Contains(item))
if (regularExpression.Matches(text))
if (stream.CanSeek)
if (context.Created)
if (form.Enabled)

if (list.IsContains(item))
if (regularExpression.Match(text))
if (stream.Seekable)
if (context.IsCreated)
if (form.IsEnabled)

public Color Color { get; set; }

firstName , e , id , packageId , centerName , name

public static MyType operator +(MyType left, MyType right)
public static bool operator ==(MyType left, MyType right)

public static MyType operator ++(MyType value)

public static MyType operator /(MyType dividend, MyType divisor)

public static MyType operator -(MyType d1, MyType d2) // incorrect!

Area , DataBinder , PublicCacheName

_centersList
_firstName
_currentCenter

parameterType , packageOperationTypeId

lblName (Label)
txtHeader (TextBox)
btnSave (Button)

ArgumentNullException , InvalidOperaionException

System.Data

<Company>.<Component>.dll
<Company>.<Project|Product|Technology>.<Component>.dll

Microsoft.CSharp.dll , Kara.CSS.Manager.dll

public int IComparer<T> {…}
public delegate bool Predicate<T> (T item)

public int ISessionChannel<TSession> {…}
public delegate TOutput Converter<TInput, TOutput> (TInput from)
public class Nullable<T> {…}
public class List<T> {…}

ArgumentExceptionIllegalCharacters
ArgumentExceptionInvalidName
ArgumentExceptionFileNotFound

public class Color {
    …
    public static Color FromArgb(…)
    { … }
}

app.controller(‘ThingController’, [ ‘$scope’, function($scope) {
   $scope.thingOne = ‘one’;
   $scope.thingTwo = ‘two’;
   $scope.getThings = function() { 
       return $scope.thingOne + ‘ ‘ + $scope.thingTwo; 
   };
}]);

app.controller(‘ThingController’, [ ‘$scope’, function($scope) {
    angular.extend($scope, {
        thingOne: ‘one’,
        thingTwo: ‘two’,
        getThings: function() { 
            return $scope.thingOne + ‘ ‘ + $scope.thingTwo; 
        }
    });
}]);

app.controller(‘ThingController’, [ ‘$scope’, function($scope) {
    // models
    angular.extend($scope, {
        thingOne: ‘one’,
        thingTwo: ‘two’
    });

    // methods
    angular.extend($scope, {
      // in HTML template, something like {{ getThings() }}
       getThings: function() { 
            return $scope.thingOne + ‘ ‘ + $scope.thingTwo; 
        }
    });
}]);

app.controller(‘ThingController’, [ ‘$scope’, function($scope) {
    // private
    var _thingOne = ‘one’,
        _thingTwo = ‘two’;

    // models
    angular.extend($scope, {
        get thingOne() {
        return _thingOne;
        },
        set thingOne(value) {
           if (value !== ‘one’ && value !== ‘two’) {
             throw new Error(‘Invalid value (‘+value+‘) for thingOne’);
        },
        get thingTwo() {
        return _thingTwo;
        },
        set thingTwo(value) {
           if (value !== ‘two’ && value !== ‘three’) {
             throw new Error(‘Invalid value (‘+value+‘) for thingTwo’);
        }
   });

    // methods
    angular.extend($scope, {
       // in HTML template, something like {{ things }}
       get things() { 
            return _thingOne + ‘ ‘ + _thingTwo; 
        }
    });
}]);

           string source =
           @"
               namespace Foo
               {
                    public class Bar
                    {
                        static void Main(string[] args)
                        {
                            Bar.SayHello();
                        }

                        public static void SayHello()
                        {
                            System.Console.WriteLine(""Hello World"");
                        }
                    }
               }
            ";

using System;
using System.Collections.Generic;
//دو فضای نامی که برای این منظور اضافه شده‌اند
using Microsoft.CSharp;
using System.CodeDom.Compiler;

namespace compilerTest
{
   class Program
   {
       static void compileIt1()
       {
           //سورس کد ما جهت کامپایل
           string source =
           @"
               namespace Foo
               {
                    public class Bar
                    {
                        static void Main(string[] args)
                        {
                            Bar.SayHello();
                        }

                        public static void SayHello()
                        {
                            System.Console.WriteLine(""Hello World"");
                        }
                    }
               }
            ";

           //تعیین نگارش کامپایلر مورد استفاده
           Dictionary<string, string> providerOptions = new Dictionary<string, string>
                {
                    {"CompilerVersion", "v3.5"}
                };
           //تعیین اینکه کد ما سی شارپ است
           CSharpCodeProvider provider = new CSharpCodeProvider(providerOptions);

           //تعیین اینکه خروجی یک فایل اجرایی است بعلاوه مشخص سازی محل ذخیره سازی فایل نهایی
           CompilerParameters compilerParams = new CompilerParameters
           {
               OutputAssembly = "D:\\Foo.EXE",
               GenerateExecutable = true
           };

           //عملیات کامپایل در اینجا صورت می‌گیرد
           CompilerResults results = provider.CompileAssemblyFromSource(compilerParams, source);

           //اگر خطایی وجود داشته باشد نمایش داده خواهد شد
           Console.WriteLine("Number of Errors: {0}", results.Errors.Count);
           foreach (CompilerError err in results.Errors)
           {
               Console.WriteLine("ERROR {0}", err.ErrorText);
           }
       }

       static void Main(string[] args)
       {
           compileIt1();

           Console.WriteLine("Press a key...");
           Console.ReadKey();
       }
   }
}

using System;
using System.Collections.Generic;
using Microsoft.CSharp;
using System.CodeDom.Compiler;
using System.Reflection;

namespace compilerTest
{
   class Program
   {
       static void compileIt2()
       {
           //سورس کد ما جهت کامپایل
           string source =
           @"
               namespace Foo
               {
                    public class Bar
                    {
                        static void Main(string[] args)
                        {
                            Bar.SayHello();
                        }

                        public static void SayHello()
                        {
                            System.Console.WriteLine(""Hello World"");
                        }
                    }
               }
            ";

           //تعیین نگارش کامپایلر مورد استفاده
           Dictionary<string, string> providerOptions = new Dictionary<string, string>
                {
                    {"CompilerVersion", "v3.5"}
                };
           //تعیین اینکه کد ما سی شارپ است
           CSharpCodeProvider provider = new CSharpCodeProvider(providerOptions);

           //نحوه تعیین مشخص سازی کامپایل در حافظه
           CompilerParameters compilerParams = new CompilerParameters
           {
               GenerateInMemory = true,
               GenerateExecutable = false
           };

           //عملیات کامپایل در اینجا صورت می‌گیرد
           CompilerResults results = provider.CompileAssemblyFromSource(compilerParams, source);

           // اگر خطایی در کامپایل وجود نداشت متد دلخواه را فراخوانی می‌کنیم
           if (results.Errors.Count == 0)
           {
               //استفاده از ریفلکشن برای دسترسی به متد و فراخوانی آن
               Type type = results.CompiledAssembly.GetType("Foo.Bar");
               MethodInfo method = type.GetMethod("SayHello");
               method.Invoke(null, null);
           }
       }


       static void Main(string[] args)
       {
           compileIt2();

           Console.WriteLine("Press a key...");
           Console.ReadKey();
       }
   }
}

           string source =
           @"
             namespace Foo
             {
            
                 public class Bar
                 {
                     static void Main(string[] args)
                     {
                         Bar.SayHello();
                     }
            
                     public static void SayHello()
                     {
                         System.Console.WriteLine(""Hello World"");
                         var r = new System.Drawing.Rectangle(0,0,100,100);
                         System.Console.WriteLine(r);             
                     }
                 }
             }
            ";

Number of Errors: 1
ERROR The type or namespace name 'Drawing' does not exist in the namespace 'System' (are you missing an assembly reference?)

compilerParams.ReferencedAssemblies.Add("System.Drawing.Dll");

شرح مثال جاری

مایکروسافت استفاده از آبجکت‌های POCO با WCF را توصیه می‌کند چرا که مرتب سازی (serialization) آبجکت موجودیت را ساده‌تر می‌کند. اما در صورتی که از آبجکت‌های POCO ای استفاده می‌کنید که changed-based notification دارند (یعنی خواص موجودیت را با virtual علامت گذاری کرده اید و کلکسیون‌های خواص پیمایشی از نوع ICollection هستند)، آنگاه EF برای موجودیت‌های بازگشتی کوئری‌ها پراکسی‌های دینامیک تولید خواهد کرد.

استفاده از پراکسی‌های دینامیک با WCF دو مشکل دارد. مشکل اول مربوط به سریال کردن پراکسی است. کلاس DataContractSerializer تنها قادر به serialize/deserialize کردن انواع شناخته شده (known types) است. در مثال جاری این یعنی موجودیت Client. اما از آنجا که EF برای موجودیت‌ها پراکسی می‌سازد، حالا باید آبجکت پراکسی را سریال کنیم، نه خود کلاس Client را. اینجا است که از DataContractResolver استفاده می‌کنیم. این کلاس می‌تواند حین سریال کردن آبجکت ها، نوعی را به نوع دیگر تبدیل کند. برای استفاده از این کلاس ما یک ویژگی سفارشی ساختیم، که پراکسی‌ها را به کلاس‌های POCO تبدیل می‌کند. سپس این ویژگی را به متد ()GetClient اضافه کردیم. این کار باعث می‌شود که پراکسی دینامیکی که توسط متد ()GetClient برای موجودیت Client تولید می‌شود، به درستی سریال شود.

مشکل دوم استفاده از پراکسی‌ها با WCF مربوط به بارگذاری تبل یا Lazy Loading می‌شود. هنگامی که DataContractSerializer موجودیت‌ها را سریال می‌کند، تمام خواص موجودیت را دستیابی خواهد کرد که منجر به اجرای lazy-loading روی خواص پیمایشی می‌شود. مسلما این رفتار را نمی‌خواهیم. برای رفع این مشکل، مشخصا قابلیت بارگذاری تنبل را خاموش یا غیرفعال کرده ایم.

<form method="post" asp-action="UploadFiles" asp-controller="Home" enctype="multipart/form-data">
    <input type="file" name="files" webkitdirectory />
    <input type="submit" value="Upload" />
</form>

using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace UploadFolderASPNETCore.Controllers
{
    public class HomeController : Controller
    {
        private readonly IWebHostEnvironment _environment;
        private const int MaxBufferSize = 0x10000;

        public HomeController(IWebHostEnvironment environment)
        {
            _environment = environment;
        }

        public IActionResult Index()
        {
            return View();
        }

        [HttpPost("[action]")]
        public async Task<IActionResult> UploadFiles(IList<IFormFile> files)
        {
            var uploadsRootFolder = Path.Combine(_environment.WebRootPath, "uploads");
            CreateDir(uploadsRootFolder);

            foreach (var file in files)
            {
                var dirPath = Path.GetDirectoryName(file.FileName);
                CreateDir(Path.Combine(uploadsRootFolder, dirPath));

                var filePath = Path.Combine(uploadsRootFolder, file.FileName);
                using (var fileStream = new FileStream(filePath, FileMode.Create,
                                                        FileAccess.Write,
                                                        FileShare.None,
                                                        MaxBufferSize,
                                                        useAsync: true
                                                        ))
                {
                    await file.CopyToAsync(fileStream);
                }
            }

            return RedirectToAction("Index");
        }

        private void CreateDir(string path)
        {
            if (!Directory.Exists(path))
            {
                Directory.CreateDirectory(path);
            }
        }
    }
}

    public class BackgroundWorkerViewModel : BaseViewModel
    {
        private List<string> _myData;

        public BackgroundWorkerViewModel()
        {
            LoadDataCommand = new RelayCommand(OnLoadData);
        }

        public RelayCommand LoadDataCommand { get; set; }

        public List<string> MyData
        {
            get { return _myData; }
            set
            {
                _myData = value;
                RaisePropertyChanged(() => MyData);
            }
        }

        public bool IsBusy { get; set; }

        private void OnLoadData()
        {
            var backgroundWorker = new BackgroundWorker();
            backgroundWorker.DoWork += (sender, e) =>
                             {
                                 MyData = new List<string> {"Test"};
                                 Thread.Sleep(1000);
                             };
            backgroundWorker.RunWorkerCompleted += (sender, e) => { IsBusy = false; };
            backgroundWorker.RunWorkerAsync();
        }
    }

    [TestFixture]
    public class BackgroundWorkerViewModelTest
    {
        #region Setup/Teardown

        [SetUp]
        public void SetUp()
        {
            _backgroundWorkerViewModel = new BackgroundWorkerViewModel();
        }

        #endregion

        private BackgroundWorkerViewModel _backgroundWorkerViewModel;

        [Test]
        public void TestGetData()
        {
              
            _backgroundWorkerViewModel.LoadDataCommand.Execute(_backgroundWorkerViewModel);

            Assert.NotNull(_backgroundWorkerViewModel.MyData);
            Assert.IsNotEmpty(_backgroundWorkerViewModel.MyData);
        }
    }

   public interface IWorker
    {
        void Run(DoWorkEventHandler doWork);
        void Run(DoWorkEventHandler doWork, RunWorkerCompletedEventHandler onComplete);
    }

    public class AsyncWorker : IWorker
    {
        public void Run(DoWorkEventHandler doWork)
        {
            Run(doWork, null);
        }

        public void Run(DoWorkEventHandler doWork, RunWorkerCompletedEventHandler onComplete)
        {
            var backgroundWorker = new BackgroundWorker();
            backgroundWorker.DoWork += doWork;
            if (onComplete != null)
                backgroundWorker.RunWorkerCompleted += onComplete;
            backgroundWorker.RunWorkerAsync();
            

        }
    }

    public class SyncWorker : IWorker
    {
        #region IWorker Members

        public void Run(DoWorkEventHandler doWork)
        {
            Run(doWork, null);
        }

        public void Run(DoWorkEventHandler doWork, RunWorkerCompletedEventHandler onComplete)
        {
            Exception error = null;
            var doWorkEventArgs = new DoWorkEventArgs(null);
            try
            {
                doWork(this, doWorkEventArgs);
            }
            catch (Exception ex)
            {
                error = ex;
                throw;
            }
            finally
            {
                onComplete(this, new RunWorkerCompletedEventArgs(doWorkEventArgs.Result, error, doWorkEventArgs.Cancel));
            }
        }

        #endregion
    }

    public class BackgroundWorkerViewModel : BaseViewModel
    {
        private readonly IWorker _worker;
        private List<string> _myData;

        public BackgroundWorkerViewModel(IWorker worker)
        {
            _worker = worker;
            LoadDataCommand = new RelayCommand(OnLoadData);
        }

        public RelayCommand LoadDataCommand { get; set; }

        public List<string> MyData
        {
            get { return _myData; }
            set
            {
                _myData = value;
                RaisePropertyChanged(() => MyData);
            }
        }

        public bool IsBusy { get; set; }

        private void OnLoadData()
        {
            IsBusy = true; // view is bound to IsBusy to show 'loading' message.

            _worker.Run(
                (sender, e) =>
                    {
                        MyData = new List<string> {"Test"};
                        Thread.Sleep(1000);
                    },
                (sender, e) => { IsBusy = false; });
        }
    }

    [TestFixture]
    public class BackgroundWorkerViewModelTest
    {
        #region Setup/Teardown

        [SetUp]
        public void SetUp()
        {
            _backgroundWorkerViewModel = new BackgroundWorkerViewModel(new SyncWorker());
        }

        #endregion

        private BackgroundWorkerViewModel _backgroundWorkerViewModel;

        [Test]
        public void TestGetData()
        {
              
            _backgroundWorkerViewModel.LoadDataCommand.Execute(_backgroundWorkerViewModel);

            Assert.NotNull(_backgroundWorkerViewModel.MyData);
            Assert.IsNotEmpty(_backgroundWorkerViewModel.MyData);
        }
    }