Алексей Немиро

Зависит от логики. Если, как показано ниже, то можно использовать continue:

int i = 0;
bool b = false;
while (i < 10)
{
	Console.WriteLine("Текущее: {0}", i);
			
	if (i == 5 && !b)
	{
		b = true;
		continue;
	}
			
	i++;
}

В крайнем случае есть goto:

int i = 0; 
bool b = false;
while (i < 10)
{
	again: // точка возврата
	Console.WriteLine("Текущее: {0}", i);
			
	if (i == 5 && !b)
	{
		b = true;
		goto again;
	}
			
	i++;
}

Посмотреть online-пример

Однако не следует злоупотреблять подобными переходами. От обилия операторов goto в коде, у программиста может случиться разрыв мозга, что приведет к неминуемой гибели проекта и его возрождению в новом виде, если, конечно, сам программист не скопытится. Травма та серьезная :-) Если есть возможность, желание и время, лучше изменить логику так, чтобы не приходилось делать такие «прыжки».

Для получения файлов или вообще работы с файлами (ожидание доступа для чтения или удаления, получение данных из сети и т.п.), можно использовать вложенный цикл, который будет пробовать выполнить задачу до тех пор, пока она будет успешно выполнена или не истечет отведенное время на выполнение задачи (или количество попыток):

// пауза между попытками (100 мс)
var interval = new TimeSpan(0, 0, 0, 0, 100); 
// максимальное время ожидания (1 секунда)
var timeout  = new TimeSpan(0, 0, 0, 1); 
while (true)
{
  var totalTime = new TimeSpan(); // счетчик времени
  var заданиеВыполнено = false;

  while(!заданиеВыполнено) // повторять, пока задание не будет выполнено
  {
    try
    {
      // тут код задания
      // если ошибок не будет, то
      заданиеВыполнено = true; // работа цикла будет завершена
    }
    catch
    {
      // если ошибка, делаем паузу
      System.Threading.Thread.Sleep(100);
      // увеличиваем счетчик времени
      totalTime += interval;
      if (totalTime > timeout)
      {
				// превышен таймаут, выходим
				Console.WriteLine("Превышено время ожидания");
				break;
      }
    }
  }
}

Для представленного XML, классы будут примерно такими:

[Serializable]
[XmlRoot("ValCurs")]
public class ValCurs
{

  [XmlAttribute("Date")]
  public string Date { get; set; }

  [XmlAttribute("name")]
  public string Name { get; set; }

  [XmlElement("Valute")]
  public Valute[] Items { get; set; }

}

[Serializable]
public class Valute
{

  [XmlAttribute("ID")]
  public string Id { get; set; }
  public string NumCode { get; set; }
  public string CharCode { get; set; }
  public string Name { get; set; }
  public string Nominal { get; set; }
  public string Value { get; set; }

}

Посмотреть пример работы этого кода в .NET Fiddle.

Фигуры фиксированного размера можно нарисовать так:

public partial class Form1 : Form
{

    private int BrushType = 1;

    public Form1()
    {
      InitializeComponent();

      // создаем PictureBox
      var pic = new PictureBox { Dock = DockStyle.Fill, BackColor = Color.White };
      pic.MouseClick += PictureBox_MouseClick;
      this.Controls.Add(pic);

      // создаем панель для кнопок
      var panel = new FlowLayoutPanel { Dock = DockStyle.Top, AutoSize = true };
      this.Controls.Add(panel);

      // кнопки
      var btn = new RadioButton 
      { 
        Text = "Круг", 
        Tag = 1, 
        Appearance = Appearance.Button, 
        Checked = true, 
        AutoSize = true 
      };
      btn.Click += Button_Click;
      panel.Controls.Add(btn);

      btn = new RadioButton
      {
        Text = "Не круг",
        Tag = 2,
        Appearance = Appearance.Button,
        AutoSize = true
      };
      btn.Click += Button_Click;
      panel.Controls.Add(btn);

      btn = new RadioButton
      {
        Text = "Квадратный круг",
        Tag = 3,
        Appearance = Appearance.Button,
        AutoSize = true
      };
      btn.Click += Button_Click;
      panel.Controls.Add(btn);
    }

    private void Button_Click(object sender, EventArgs e)
    {
      var btn = (RadioButton)sender;
      this.BrushType = (int)btn.Tag;
    }

    private void PictureBox_MouseClick(object sender, MouseEventArgs e)
    {
      // получаем ссылку на PictureBox
      var pic = (PictureBox)sender;
      // получаем Graphics из PictureBox
      var g = pic.CreateGraphics();

      if (this.BrushType == 2)
      {
        // рисуем не круглый квадрат
        g.DrawRectangle(Pens.Black, e.X, e.Y, 50, 50);
      }
      else if (this.BrushType == 3)
      {
        // рисуем квадратный круг
        Point[] points = new Point[6];
        int half = 50 / 2;
        int quart = 50 / 4;
        points[0] = new Point(e.X + quart, e.Y);
        points[1] = new Point(e.X + 50 - quart, e.Y);
        points[2] = new Point(e.X + 50, e.Y + half);
        points[3] = new Point(e.X + 50 - quart, e.Y + 50);
        points[4] = new Point(e.X + quart, e.Y + 50);
        points[5] = new Point(e.X, e.Y + half);
        g.DrawPolygon(Pens.Black, points);
      }
      else
      {
        // рисуем эллипс
        g.DrawEllipse(Pens.Black, e.X, e.Y, 50, 50);
      }
    }

}

В качестве кнопок используются RadioButton, т.к. это удобней.
Чтобы не стиралось, можно сделать Bitmap:

var pic = (PictureBox)sender;
if (pic.Image == null) { pic.Image = new Bitmap(pic.Width, pic.Height); }
var bmp = new Bitmap(pic.Image);
var g = Graphics.FromImage(bmp);

И после завершения рисования, передать картинку в PictureBox:
pic.Image = bmp;

Результат:

Чтобы класс можно было сериализовать, необходимо пометить его атрибутом [Serializable].

[Serializable]
public class MyClass 
{
}

Атрибут [Serializable] также должны иметь все типы, которые включены в класс. Если у какого-то из типов не будет этого атрибута, то при попытке выполнить сериализацию, возникнет исключение. Это минимум, что необходимо.

Для двоичной сериализации используется класс BinaryFormatter.

// данные, которые будем сериализовать
var data = new List<int> { 1, 2, 3 };

// выполняем сериализацию 
// в MemoryStream (можно в любой Stream)
var bf = new BinaryFormatter();
var m = new MemoryStream();
bf.Serialize(m, data);
            
// курсор потока переводим в начало, т.к. мы работали с потоком выше
// если открывать новый поток, то это делать не обязательно
m.Position = 0;
// выполняем десериализацию данных из MemoryStream
var result = (List<int>)bf.Deserialize(m);

// выводим результат в консоль
result.ForEach(itm => Console.WriteLine(itm));

Если в объекте попадется тип, который не помечен атрибутом [Serializable], то можно реализовать в классе интерфейс ISerializable. Либо сделать для этого типа отдельный класс, реализующий интерфейс ISerializable. При этом, не забывая про атрибут [Serializable], который обязательно должен присутствовать.

При реализации интерфейса ISerializable, в классе нужно определит метод GetObjectData, который будет подготавливать данные для сериализации. А также реализовать перегрузку конструктора для принятия сериализованных данных.

public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
{
  if (info == null)
  {
    throw new ArgumentNullException("info");
  }
  info.AddValue("Ключ", "Значение");
  info.AddValue("Ключ2", this.ИмяСвойства); 
  // и т.д.
}

// конструктор
protected ИмяКласса(SerializationInfo info, StreamingContext context)
{
  if (info == null)
  {
    throw new ArgumentNullException("info");
  }
  this.Свойство = info.GetValue("Ключ", typeof(типДанных));
  this.ИмяСвойства = (string)info.GetValue("Ключ2", typeof(string));
  // и т.д.
}

Часто спрашивают, как сериализовать Dictionary<TKey, TValue>. На основе всего выше изложенного, можно сделать вот такой класс:

[Serializable]
public class MyDictionary : Dictionary<string, object>, ISerializable
{

  public MyDictionary() { }

  protected MyDictionary(SerializationInfo info, StreamingContext context)
  {
    if (info == null)
    {
      throw new ArgumentNullException("info");
    }
    int count = info.GetInt32("Count"); // получаем число элементов
    for (int i = 0; i < count; i++) // перебираем элементы
    {
      // получаем ключ и значение по индексу элемента
      string key = info.GetString(String.Format("ItemKey{0}", i));
      object value = info.GetValue(String.Format("ItemValue{0}", i), typeof(object));
      // добавляем элемент в себя
      this.Add(key, value);
    }
  }

  public void GetObjectData(SerializationInfo info, StreamingContext context)
  {
    if (info == null)
    {
      throw new ArgumentNullException("info");
    }
    // перебираем все элементы коллекции
    int i = 0;
    foreach (KeyValuePair<string, object> item in this)
    {
      // добавляем отдельно ключ и значение
      info.AddValue(String.Format("ItemKey{0}", i), item.Key, typeof(string));
      info.AddValue(String.Format("ItemValue{0}", i), item.Value);
      i++;
    }
    // запоминаем, сколько всего элементов
    info.AddValue("Count", this.Count);
  }
}

Пример использования:

// выполняем сериализацию коллекции
var data = new MyDictionary();
data.Add("Key", "Value");
data.Add("Key2", "Value2");
data.Add("Key3", 123);

var bf = new BinaryFormatter();
var m = new MemoryStream();
bf.Serialize(m, data);

// выполняем десериализацию
m.Position = 0;
var result = (MyDictionary)bf.Deserialize(m);

// выводим результат
foreach (var item in result)
{
  Console.WriteLine("{0} = {1}", item.Key, item.Value);
}

Посмотреть в .NET Fiddle, как это работает.

Для редактирования использовать тип string. Перед сохранение в базу преобразовывать в decimal.
В своих проектах использую вспомогательный класс, который имеет методы для работы с числами и умеет понимать любой десятичный разделитель. Конкретно, для данной ситуации, есть метод ToDecimal (код открыт, лицензия не запрещает использовать частями, если что).

[DisplayName("Сумма")]
public string Sum { get; set; }

public decimal SumDec 
{ 
  get
  { 
    return Convertion.ToDecimal(this.Sum); 
  }
}

Метод Serialize перегружен и, помимо прочего, может принимать TextWriter, от которого наследуется StringWriter.

Я недавно выпустил библиотеку с формами аутентификации через социальные сети по протоколу OAuth. На данный момент есть клиенты для 17 популярных сервисов.

Исходный код открыт, распространяется под лицензией Apache 2.0.

Пример использования:

// создаем форму для Dropbox
var login = new DropboxLogin("5nkunr8uscwfoba", "n7x9icfwoe6dehq") { Owner = this };
// показываем форму
login.ShowDialog();
// если пользователь авторизован
if (login.IsSuccessfully)
{
  // можем получить маркер доступа и использовать для работы с API Dropbox
  MessageBox.Show("Маркер доступа: " + login.AccessToken.Value);
}

Без читов точно не пройти! :-)

Странный вопрос. Запустить проект, в котором размещен этот тест и посмотреть на отчет.
Если будут ошибки, внеси соответствующие исправления в код. Обычно это делается так.

----------
Подведу итоги по результатам дискуссии в комментариях.

1. Простые/тупые варианты пройти тест успешно, по крайней мере технически, это внести изменения в данные:

return x > value - 1000; // убираем лишнюю тысячу :)

return x + 1000 > value; // добавляем

2. Самый очевидный и, более ли менее правильный вариант, по крайней мере на практике (хотя лучше вообще избегать таких ситуаций), использовать дополнительную переменную для сохранения значения:

var value = 0;
var value2 = value;
var predicates = new Predicate[]
{
  x => x > value2
};

3. Еще могу предложить построить дерево. Но это сложное решение, кода больше. Хотя, если вы проходили/изучаете именно эту тему, то вполне возможно, что этот вариант может быть правильным.

// using System.Linq.Expressions;

[TestMethod]
public void FunctionExtention_CombinePredicates_Should_Avoid_Closure()
{
    var value = 0;

    var iks = Expression.Parameter(typeof(int), "x");
    var v = Expression.Constant(value, typeof(int)); // фиксируем значение value 
    var less = Expression.LessThan(v, iks);
    var l = Expression.Lambda<Func<int, bool>>(less, new ParameterExpression[] { iks }).Compile();

    var predicates = new Predicate<int>[]
    {
      x => l(x)
    };
    var result = FunctionExtentions.CombinePredicates(predicates);
    value = 1000; // This should not affect the call above!
    Assert.IsTrue(result(2));
    Assert.IsTrue(result(5));
    Assert.IsTrue(result(1000));
    Assert.IsFalse(result(-20));
    Assert.IsFalse(result(0));
    Assert.IsFalse(result(-1000));
}

public static Predicate<T> CombinePredicates<T>(Predicate<T>[] predicates)
{            
    return item => predicates.All(predicate => predicate(item));
}

ReadByte возвращает тип int, т.к. при достижении конца будет возвращено значение минус один. А тип byte может иметь значение в диапазоне от нуля до 255. То есть, считывая байты, сообщить о достижении конца потока при помощи типа byte невозможно (байт, имеющий значение ноль может быть полезным байтом), поэтому используется тип int.

Метод Read принимает буфер, в который будут помещены считанные данные. Буфер - это массив байт. Изначально он должен быть пустым. Размер массива - по своему смотрению. Чем больше размер буфера, тем больше данных будет помещено в память, меньше проделано операций.

Метод Read возвращает число помещенных в буфер байт. Ноль - достигнут конец потока.

FileInfo f = new FileInfo(@"C:\example.dat");
using (FileStream fs = f.Open(FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
 using (BinaryReader br = new BinaryReader(fs))
 {
   int bytesRead = 0;
   byte[] buffer = new byte[256]; // размер буфера 256 единиц байт
   StringBuilder result = new StringBuilder();
   while ((bytesRead = br.Read(buffer, 0, buffer.Length)) != 0) // читаем не более 256 единиц байт в buffer
   {
     // из buffer следует извлекать не более bytesRead (в конце это число может быть меньше 255)
   }
 }
}

Массивы являются ссылочными типами и нет необходимости использовать out.

Первое:
Лучше изначально строить структуру проекта так, чтобы файловое хранилище было независимым и при высоких нагрузках не валило основной сайт, и чтобы в будущем было проще масштабировать проект.

Проще говоря, как минимум следует использовать разные домены/сайты для хранилищ файлов.

Например, основной сайт:
example.org
А хранилище файлов:
storage1.example.org

Даже размещая основной сайт и хранилище(а) на одном сервере, можно будет распределить нагрузку между проектами.

Тогда и проблема с mime отпадет сама собой.

Второе: Если файлы выдаются серверным кодом, то достаточно добавить заголовок Content-Disposition, чтобы браузер предложил пользователю скачать файл:

Response.AddHeader("Content-Disposition", "attachment; filename=123.gif");

Шаблон может быть такой:
[A-Za-z]{1}[0-9]{1}

Более строго, с начала строки и до конца:
^[A-Za-z]{1}[0-9]{1}$

[A-Za-z] - буквы в заданном диапазоне, можно заменить на необходимый набор символов.
[0-9] - числа от нуля до девяти, равносильно \d
{1} - строго один символ.
^ - в данном случае - начало строки.
$ - конец строки.

Одна буква и много чисел:
^[A-Za-z]{1}\d+$
+ - один или более символов.

Придется делать конструктор в FileMember, который будет принимать Grid и строить себя на его основе. В этом случае связь с исходным объектом потеряется (если критично).

Как вариант, можно убрать наследование и сделать в FileMember свойство, принимающее Grid. Будет проще передавать Grid в FileMember :) Но придется изрядно доработать FileMember, чтобы он вел себя как Grid. По сути тупая переадресация будет (но подводные камни исключать нельзя, все может оказаться сложнее).

В итоге нужно выбрать, что будет проще: копировать исходный Grid в FileMember; или определить все свойства, методы Grid и т.п. в FileMember; или отказаться от идеи передавать Grid, использовать только FileMember, изменить исходную задачу на вариант с более простым решением.