Лето

using System.Windows.Media;
using System.Windows.Media.Imaging;
if (counters == 6)
{
    ImageSourceConverter converter = new ImageSourceConverter();
    string path = "/x-prolog_1.jpg";
    ImageSource imageSource = (ImageSource)converter.ConvertFromString(path);
    img.Source = imageSource;
}

Добавлено: 22 Марта 2014 05:06:14 Добавил: Андрей Ковальчук

говнопоток

class ThreadTest 
{
  static void Main()
  {
    Thread t = new Thread(WriteY);
    t.Start();            // Выполнить WriteY в новом потоке
    while (true) 
      Console.Write("x"); // Все время печатать 'x'
  }
 
  static void WriteY() 
  {
    while (true) 
      Console.Write("y"); // Все время печатать 'y'
  }
}


Добавлено: 10 Февраля 2014 03:25:02 Добавил: Андрей Ковальчук

Класс FTP

Класс FTP предназначен для работы с сервером FTP

Конструктор класса

public FTP (string Host, int Port, string User, string Password)

Создает объект и инициализирует параметры соединения с сервером FTP

Параметры:

Host – имя или IP адрес сервера FTP;
Port – номер порта сервера FTP;
User – имя учетной записи;
Password – пароль учетной записи;
Методы класса
public bool UploadFile (string PathFTP, string NameFile)

Записывает файл NameFile на сервер FTP по указанному пути PathFTP.

Параметры:

PathFTP – путь;
NameFile – имя файла.
Возвращаемый результат:

Возвращает true, если запись файла прошла успешно, иначе возвращает false.
Примечание:

Путь PathFTP указывается без конечного слэша.
public bool DownloadFile (string NameFileFTP, string NameFileLocal)

Загружает файл NameFileFTP c сервера FTP и записывает загруженный файл, на локальный компьтер с именем NameFileLocal.

Параметры:

NameFileFTP – имя файла на сервере FTP;
NameFileLocal – имя файла на локальном компьютере.
Возвращаемый результат:

Возвращает true, если загрузка файла прошла успешно, иначе возвращает false.
public string[] ListDirectory (string PathFTP, bool Details)

Формирует список файлов и каталогов, находящихся в указанном PathFTP на сервере FTP.

Параметры:

PathFTP – путь к каталогу на сервере FTP;
Details – форма выдачи данных. При Details = true полная форма выдачи данных, иначе краткая. Полная форма выдачи данных зависит от платформы, на которой установлен сервер FTP.
Платформа Windows
06-04-10 09:25AM Book
06-15-06 10:27AM docs
02-20-07 03:13PM docum
12-30-10 10:40AM Instr
06-30-09 02:04PM Monitoring
01-31-11 11:20AM 28027 POOL.RET
03-05-10 01:58PM Program
01-31-11 09:44AM Tov
01-31-11 11:20AM 97960 user.net
11-24-10 02:00PM Бланки
12-18-08 01:46PM 339248 Схема серверов ЦУМР.emf

Платформа Unix
dr-xr-xr-x 1 user group 0 Feb 3 13:27 ! ВНИМАНИЕ! НОВОСТИ!
dr-xr-xr-x 1 user group 0 Feb 4 09:40 !Обновление_компонентов
dr-xr-xr-x 1 user group 0 Jan 24 18:51 .
dr-xr-xr-x 1 user group 0 Jan 24 18:51 ..
dr-xr-xr-x 1 user group 0 Jan 21 09:38 1
dr-xr-xr-x 1 user group 0 Nov 8 11:20 2
dr-xr-xr-x 1 user group 0 Sep 30 15:39 A-TRANS
dr-xr-xr-x 1 user group 0 Dec 9 09:36 ARMENIA
dr-xr-xr-x 1 user group 0 Nov 8 2009 ARMOPD(WIN)
dr-xr-xr-x 1 user group 0 Jan 13 17:18 ARM_CD
dr-xr-xr-x 1 user group 0 Nov 25 10:55 DB2_Грузовой _экспресс

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

Возвращаемый результат:

Строковый массив списка файлов и каталогов. Если в указанном каталоге, файлов и каталогов нет, возвращается строковый массив нулевой длины.
public string[] ListNameFile (string PathFTP, bool Files)

Формирует список файлов или каталогов, находящихся в указанном PathFTP на сервере FTP.

Параметры:

PathFTP – путь к каталогу на сервере FTP;
Files – определяет содержимое списка. При Files = true выдается список файлов, иначе список каталогов.
Возвращаемый результат:

Строковый массив списка файлов или каталогов. Еcли в указанном каталоге на сервере FTP файлов или каталогов нет, возвращается строковый массив нулевой длины.
Примечание:

Если внутри имени файла или каталога присутствуют пробелы, то такая строка обрамляется в двойные кавычки. Путь PathFTP должен иметь конечный символ “\”.
Свойства класса
public string Err { get; }

Возвращает строку с сообщением об ошибке, возникшей при работе с FTP, или пустую строку, если ошибок нет.

Пример использования класса FTP
//****************************************
// Пример использования класса FTP
//****************************************

using System;
using SF;

…

// создаем объект
FTP oSF = new FTP("10.240.3.110", 21, "anonymous", "alex@mail.ru");

// запись файла с локального компьютера на сервер FTP
if (oSF.UploadFile(@"Program\User", @"d:\temp\alfa.doc"))
  Console.WriteLine("Файл записан");
else
  Console.WriteLine("Ошибка! " + oSF.Err);

// загрузка файла с сервера FTP на локальный компьютер
if (oSF.DownloadFile(@"Program\User\alfa.doc", @"d:\temp\alfa.doc"))
  Console.WriteLine("Файл загружен");
else
  Console.WriteLine("Ошибка! " + oSF.Err);

// получить список файлов и каталогов по указанному пути
string[] ListDir = oSF.ListDirectory(@"Program\User", false);
if (ListDir.Length > 0) {
  Console.WriteLine("Список файлов:");
  for (int i = 0; i < ListDir.Length; i++)
    Console.WriteLine(ListDir[i]); 
}
else
  Console.WriteLine("Список пуст");

// получить только список файлов
string[] ListFile = oSF.ListNameFile(@"Program\User", true);
if (ListFile.Length > 0) {
  Console.WriteLine("Список файлов:");
  for (int i = 0; i < ListFile.Length; i++)
    Console.WriteLine(ListFile[i]); 
}
else
  Console.WriteLine("Список пуст");

…

Код класса
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Text;
using System.Text.RegularExpressions;


namespace SF {

public struct FileStruct {
  public string Flags;
  public string Owner;
  public string Group;
  public bool IsDirectory;
  public DateTime CreateTime;
  public string Name;
}

public enum FileListStyle {
  UnixStyle,
  WindowsStyle,
  Unknown
}

// Класс для работы с FTP
public class FTP {
  private string Host;
  private int Port;
  private string User;
  private string Password;
  private string Error;

  //*************************************************************
  //* Function: FTP
  //* Notes: Конструктор класса
  //*

  public FTP (string Host, int Port, string User, string Password) {
    this.Host = Host;
    this.Port = Port;
    this.User = User;
    this.Password = Password;
    this.Error = "";
  }

  //*** End of FTP ***********

  //*************************************************************
  //* Function: UploadFile
  //* Notes: Запись файла на FTP
  //*

  public bool UploadFile (string PathFTP, string NameFile) {
    FileInfo InfoFile = new FileInfo(NameFile);
    FtpWebRequest Request;
    string UploadUri = "";

    this.Error = "";
    if (PathFTP == "")
      UploadUri = "ftp://" + this.Host + ":" + this.Port.ToString() + "/" +
                  InfoFile.Name;
    else
      UploadUri = "ftp://" + this.Host + ":" + this.Port.ToString() + "/" +
                  PathFTP + "/" + InfoFile.Name;
    Request = (FtpWebRequest)FtpWebRequest.Create(UploadUri);
    Request.Credentials = new NetworkCredential(this.User, this.Password);
    Request.KeepAlive = false;
    Request.Method = WebRequestMethods.Ftp.UploadFile;
    Request.UseBinary = true;
    Request.ContentLength = InfoFile.Length;
    int BuffLength = 2048;
    byte[] Buff = new byte[BuffLength];
    int ContentLen;
    FileStream FS = InfoFile.OpenRead();
    try {
      Stream Strm = Request.GetRequestStream();
      ContentLen = FS.Read(Buff, 0, BuffLength);
      while (ContentLen != 0) {
        Strm.Write(Buff, 0, ContentLen);
        ContentLen = FS.Read(Buff, 0, BuffLength);
      }
      // закрываем все потоки
      Strm.Close();
      FS.Close();
      return true;
    }
    catch (Exception e) {
      this.Error = e.Message;
      return false;
    }
  }

  //*** End of UploadFile ***********

  //*************************************************************
  //* Function: DownloadFile
  //* Notes: Загружает файл NameFileFTP c сервера  FTP и записывает
  //*        загруженный файл, на локальный компьтер с  именем NameFileLocal.
  //*

  public bool DownloadFile (string NameFileFTP, string NameFileLocal) {
    FtpWebRequest Request;
    string DownloadUri = "";

    try {
      FileStream OutputStream = new FileStream(NameFileLocal, FileMode.Create);
      this.Error = "";
      DownloadUri = "ftp://" + this.Host + ":" + this.Port.ToString() + "/" +
                    NameFileFTP;
      Request = (FtpWebRequest)FtpWebRequest.Create(DownloadUri);
      Request.Method = WebRequestMethods.Ftp.DownloadFile;
      Request.UseBinary = true;
      Request.Credentials = new NetworkCredential(this.User, this.Password);
      FtpWebResponse Response = (FtpWebResponse)Request.GetResponse();

      Stream FtpStream = Response.GetResponseStream();
      long cl = Response.ContentLength;
      int BufferSize = 2048;
      int ReadCount;
      byte[] Buffer = new byte[BufferSize];

      ReadCount = FtpStream.Read(Buffer, 0, BufferSize);
      while (ReadCount > 0) {
        OutputStream.Write(Buffer, 0, ReadCount);
        ReadCount = FtpStream.Read(Buffer, 0, BufferSize);
      }
      // закрываем все потоки
      FtpStream.Close();
      OutputStream.Close();
      Response.Close();
      return true;
    }
    catch (Exception e) {
      this.Error = e.Message;
      return false;
    }
  }

  //*** End of DownloadFile ***********

  //*************************************************************
  //* Function: ListDirectory
  //* Notes: Возвращает строковый массив списка файлов и каталогов,
  //*        находящихся в указанном каталоге
  //*

  public string[] ListDirectory (string PathFTP, bool Details) {
    string[] DownloadFiles;
    StringBuilder Result = new StringBuilder();
    FtpWebRequest Request;
    string UriFTP = "";

    try {
      this.Error = "";
      if (PathFTP == "")
        UriFTP = "ftp://" + this.Host + ":" + this.Port.ToString() + "/";
      else
        UriFTP = "ftp://" + this.Host + ":" + this.Port.ToString() + "/" +
                 PathFTP;
      Request = (FtpWebRequest)FtpWebRequest.Create(UriFTP);
      Request.UseBinary = true;
      Request.Credentials = new NetworkCredential(this.User, this.Password);
      if (Details)
        Request.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
      else
        Request.Method = WebRequestMethods.Ftp.ListDirectory;
      WebResponse Response = Request.GetResponse();
      StreamReader Reader = new StreamReader(Response.GetResponseStream(),
                                             Encoding.GetEncoding(1251));
      string Line = Reader.ReadLine();
      while (Line != null) {
        Result.Append(Line);
        Result.Append("\n");
        Line = Reader.ReadLine();
      }
      Reader.Close();
      Response.Close();
      if (Result.Length != 0) {
        Result.Remove(Result.ToString().LastIndexOf('\n'), 1);
        return Result.ToString().Split('\n');
      }
      else {
        return (new string[0]);
      }
    }
    catch (Exception e) {
      this.Error = e.Message;
      DownloadFiles = new string[0];
      return DownloadFiles;
    }
  }

  //*** End of ListDirectory ***********

  //*************************************************************
  //* Function: ListNameFile
  //* Notes: Возвращает строковый массив списка файлов или каталогов
  //*        находящихся в указанном каталоге
  //*

  public string[] ListNameFile (string PathFTP, bool Files) {
    FtpWebRequest Request;
    string[] ListFile;
    string UriFTP = "";
    int NumDir = 0;
    int NumFile = 0;

    try {
      this.Error = "";
      if (PathFTP == "")
        UriFTP = "ftp://" + this.Host + ":" + this.Port.ToString() + "/";
      else
        UriFTP = "ftp://" + this.Host + ":" + this.Port.ToString() + "/" +
                 PathFTP;
      Request = (FtpWebRequest)FtpWebRequest.Create(UriFTP);
      Request.UseBinary = true;
      Request.Credentials = new NetworkCredential(this.User, this.Password);
      Request.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
      WebResponse Response = Request.GetResponse();
      StreamReader Reader = new StreamReader(Response.GetResponseStream(),
                                             Encoding.GetEncoding(1251));
      string Datastring = Reader.ReadToEnd();
      Reader.Close();
      Response.Close();
      FileStruct[] List = GetList(Datastring);
      foreach (FileStruct thisstruct in List) {
        if (thisstruct.IsDirectory)
          NumDir++;
        else
          NumFile++;
      }
      if (Files) {
        ListFile = new string[NumFile];
        if (NumFile == 0)
          return ListFile;
      }
      else {
        ListFile = new string[NumDir];
        if (NumDir == 0)
          return ListFile;
      }
      int j = 0;
      for (int i = 0; i < List.Length; i++) {
        if (Files && !List[i].IsDirectory)
          ListFile[j++] = List[i].Name;
        else if (!Files && List[i].IsDirectory)
          ListFile[j++] = List[i].Name;
      }
      return ListFile;
    }
    catch (Exception e) {
      this.Error = e.Message;
      return new string[0];
    }
  }

  //*** End of ListNameFile ***********

  //*************************************************************
  //* Function: GetList
  //*

  private FileStruct[] GetList (string DataStr) {
    List<FileStruct> ListArray = new List<FileStruct>();
    string[] DataRec = DataStr.Split('\n');
    FileListStyle DirListStyle = GetFileListStyle(DataRec);
    foreach (string s in DataRec) {
      if (DirListStyle != FileListStyle.Unknown && s != "") {
        FileStruct FS = new FileStruct();
        FS.Name = "..";
        switch (DirListStyle) {
          case FileListStyle.UnixStyle:
            FS = ParseFileStructUnixStyle(s);
            break;
          case FileListStyle.WindowsStyle:
            FS = ParseFileStructWindowsStyle(s);
            break;
        }
        if (!(FS.Name == "." || FS.Name == "..")) {
          ListArray.Add(FS);
        }
      }
    }
    return ListArray.ToArray();
  }

  //*** End of GetList ***********

  //*************************************************************
  //* Function: ParseFileStructUnixStyle
  //*

  private FileStruct ParseFileStructUnixStyle (string Record) {
    // dr-xr-xr-x   1 owner    group               0 Nov 25  2002 bussys
    FileStruct FS = new FileStruct();
    string ProcStr = Record.Trim();
    if (ProcStr.ToLower() == "total 0") {
      FS.Name = "";
      return FS;
    }
    FS.Flags = ProcStr.Substring(0, 9);
    FS.IsDirectory = (FS.Flags[0] == 'd');
    ProcStr = (ProcStr.Substring(11)).Trim();
    CutSubstr(ref ProcStr, ' ', 0);
    FS.Owner = CutSubstr(ref ProcStr, ' ', 0);
    FS.Group = CutSubstr(ref ProcStr, ' ', 0);
    CutSubstr(ref ProcStr, ' ', 0);
    try {
      FS.CreateTime = DateTime.Parse(CutSubstr(ref ProcStr, ' ', 8));
    }
    catch {
      FS.CreateTime = DateTime.Now;
    }
    if (ProcStr.IndexOf(" ") > 0)
      FS.Name = "\"" + ProcStr + "\"";
    else
      FS.Name = ProcStr;
    return FS;
  }

  //*** End of ParseFileStructUnixStyle ***********

  //*************************************************************
  //* Function: ParseFileStructWindowsStyle
  //*

  private FileStruct ParseFileStructWindowsStyle (string Record) {
    // 02-03-04  07:46PM       <DIR>          Append
    FileStruct FS = new FileStruct();
    string ProcStr = Record.Trim();
    string DateStr = ProcStr.Substring(0, 8);
    ProcStr = (ProcStr.Substring(8, ProcStr.Length - 8)).Trim();
    string TimeStr = ProcStr.Substring(0, 7);
    ProcStr = (ProcStr.Substring(7, ProcStr.Length - 7)).Trim();
    try {
      FS.CreateTime = DateTime.Parse(DateStr + " " + TimeStr);
    }
    catch {
      FS.CreateTime = DateTime.Now;
    }
    if (ProcStr.Substring(0, 5) == "<DIR>") {
      FS.IsDirectory = true;
      ProcStr = (ProcStr.Substring(5, ProcStr.Length - 5)).Trim();
    }
    else {
      string[] StrS = ProcStr.Split(new char[] { ' ' },
        StringSplitOptions.RemoveEmptyEntries);
      // имя файла с пробелами внутри, обрамляем строку двойными кавычками
      if (StrS.Length > 2) {
        ProcStr = "";
        for (int i = 1; i < StrS.Length; i++)
          ProcStr = ProcStr + StrS[i] + " ";
        ProcStr = "\"" + ProcStr.Trim() + "\"";
      }
      else
        ProcStr = StrS[1].Trim();
      FS.IsDirectory = false;
    }
    FS.Name = ProcStr;
    return FS;
  }

  //*** End of ParseFileStructWindowsStyle ***********

  //*************************************************************
  //* Function: GetFileListStyle
  //* Notes:
  //*

  public FileListStyle GetFileListStyle (string[] RecList) {
    foreach (string s in RecList) {
      if (s.Length > 10
          && Regex.IsMatch(s.Substring(0, 10),
            "(-|d)(-|r)(-|w)(-|x)(-|r)(-|w)(-|x)(-|r)(-|w)(-|x)")) {
        return FileListStyle.UnixStyle;
      }
      else if (s.Length > 8
               && Regex.IsMatch(s.Substring(0, 8),
                 "[0-9][0-9]-[0-9][0-9]-[0-9][0-9]")) {
        return FileListStyle.WindowsStyle;
      }
    }
    return FileListStyle.Unknown;
  }

  //*** End of GetFileListStyle ***********

  //*************************************************************
  //* Function: CutSubstr
  //* Notes:
  //*

  private string CutSubstr (ref string s, char c, int startIndex) {
    int pos1 = s.IndexOf(c, startIndex);
    string retString = s.Substring(0, pos1);
    s = (s.Substring(pos1)).Trim();
    return retString;
  }

  //*** End of CutSubstr ***********

  // получить сообщение об ошибке
  public string Err {
    get {
      return this.Error;
    }
  }

}

}

Добавлено: 21 Сентября 2013 10:44:07 Добавил: Андрей Ковальчук

Пример системы плагинов

Придумал я себе такую задачу, как разработать к программе систему плагинов (add-in-ов). Немного поковыряв AddIn которые были предложены начиная с .NET 3.5, понял что они мне не подходят. Во-первых это не удобное расположение каталогов, много лишних. Во-вторых не возможно внедриться в какую нибудь часть процесса и сделать по своему, т.е. слабая расширяемость. И решил изобрести велосипед…

В основу я поставил изолированность от главного приложения и возможность песочницы. Это все не сложно сделать создав новый AppDomain и сконфигурировав его на InternetZone. Но при разработке я столкнулся с проблемой при загрузке сборки с плагином в домен. Проблема заключалась в ошибке со связями. Для загрузки я использую AppDomain.Load(). Как позже оказалось этот метод мне не подходит. По-этому пришлось сделать не большой костыль, о котором я и расскажу.

Начнем с создания нового проекта и консольного приложения (я назвал его PluginHost) и добавим еще один проект библиотеку классов (назовем её PluginFramework). В библиотеку добавим класс:

public abstract class Plugin: MarshalByRefObject
{
   public virtual void Initialize()
   {
   }
}

И еще один класс, без которого было сложно реализовать необходимую мне логику:
public class AssemblyHelper: MarshalByRefObject
{
private AppDomain _currentDomain;
public AssemblyHelper()
{
_currentDomain = AppDomain.CurrentDomain;
_currentDomain.AssemblyResolve += new ResolveEventHandler(_currentDomain_AssemblyResolve);
}
Assembly _currentDomain_AssemblyResolve(object sender, ResolveEventArgs e)
{
string[] nameSplit = e.Name.Split(',');
string path = Path.Combine(SearchFolder, nameSplit[0] + ".dll");
Assembly loadedAssembly;
try
{
loadedAssembly = Assembly.LoadFile(path);
}
catch (Exception exc)
{
Exception exp = exc;
throw;
}
if (loadedAssembly != null)
{
return loadedAssembly;
}
else
{
return null;
}
}
public string SearchFolder { get; set; }
}

Базовый каркас готов. Не большое отступление чего же я собственно хотел добиться:

Еще раз изолированность от основного приложения
В любой момент загрузка и выгрузка плагина. Если к примеру плагин упал, мы его просто выгрузим и заново загрузим
Что же у нас в Main:

Для начала я загружая сборку PluginFramework в режиме только для рефлексии и получаю Type нашего базового класса для всех плагинов
Assembly frameworkReflect =
Assembly.ReflectionOnlyLoadFrom(Path.Combine(Environment.CurrentDirectory, "PluginFramework.dll"));
Type basePluginType = frameworkReflect.GetType("MyPluginSample.Framework.Plugin");

А теперь поиск по всем имеющимся папкам
string pathPlugins = Path.Combine(Environment.CurrentDirectory, "Plugins");
DirectoryInfo directoryPlugins = new DirectoryInfo(pathPlugins);
foreach (var dir in directoryPlugins.GetDirectories())
{
FileInfo dllFile = dir.GetFiles(dir.Name + ".dll").First();

И опять я загружаю сборку в режиме только для рефлексии, но уже с плагином и ищу класс который наследуется от базового класса Plugin. Что бы мы здесь могли загрузить сборку с плагином и сравним с базовым типом нам и пришлось в начале PluginFramework тоже загрузить только для рефлексии.
Assembly reflectionAsm = Assembly.ReflectionOnlyLoadFrom(dllFile.FullName);
Type typePlugin = reflectionAsm.GetTypes().First(t => t.IsSubclassOf(basePluginType));

Теперь можно приступить к созданию нового домена, загрузить в него все необходимое и запустить наш плагин на выполнение
AppDomain pluginDomain = AppDomain.CreateDomain(dir.Name + " plugin");
AssemblyHelper helper = (AssemblyHelper)pluginDomain.CreateInstanceAndUnwrap("PluginFramework", "MyPluginSample.Framework.AssemblyHelper");
helper.SearchFolder = dir.FullName;
Plugin plugin = (Plugin)pluginDomain.CreateInstanceAndUnwrap(reflectionAsm.FullName, typePlugin.FullName);
plugin.Initialize();
}

Вот и все! И напишем тестовый плагин для проверки
public class MyPlugin1: Plugin
{
public override void Initialize()
{
Console.WriteLine("Executing in Plugin 1. Domain Id: {0}", AppDomain.CurrentDomain.Id);
}
}

Структура каталогов следующая:


Добавлено: 21 Сентября 2013 10:41:32 Добавил: Андрей Ковальчук

Пример создания динамического массива

Динамическим считается массив, который способен в любой момент изменять свой размер. Эта возможность обеспечивается за счет динамического выделения памяти под массив. При этом удобно создать класс, который является оболочкой для данного массива, отвечает за выделение и освобождение памяти под массив, а также обеспечивает доступ к элементам массива.

Когда пользователь создает объект класса-оболочки, конструктор класса выделяет память под массив, который имеет либо указанный пользователем размер, либо размер, заданный по умолчанию. Если по мере заполнения массива вся выделенная память окажется занятой, то при добавлении очередного элемента выделенная ранее память освобождается, все хранящиеся в массиве значения сохраняются во временном массиве. Затем выделяется память под массив большего размера и в него помещаются сохраненные значения. Таким образом, изменение размера массива происходит автоматически, невидимо для пользователя.

В настоящее время практически отпала необходимость использовать подобные динамические массивы, поскольку такие структуры данных, называемые контейнерами, в большом ассортименте представлены в стандартной библиотеке шаблонов С++ - Standard template library (STL), которая поддерживается практически всеми компиляторами. Наиболее типичным примером является класс vector, который содержит все необходимые функции и итераторы. Также полезными являются такие классы-контейнеры, как map, multymap, queue, deque, list, set, multyset.

Краткое описание:

map - ассоциативный массив, который содержит пары "ключ - значение", обеспечивает доступ к значению по ключу.
multymap -ассоциативный массив, в котором могут встречаться одинаковые по значению ключи.
queue - очередь, т.е. массив, организованный по принципу FIFO ("first in first out")
deque - очень напоминает vector; также как и vector поддерживает произвольный доступ к элементам, но не поддерживает некоторые функции, которые присутствуют в классе vector.
list - список, которые не поддерживает доступ к элементу по индексу; вместо этого осуществляется поиск элемента по значению.
set - множество (или простой ассоциативный массив), которое отличается от ассоциативного массива тем, что в нем ключ является одновременно и значением (имеет интерфейс, напоминающий интерфейс map, что позволяет безболезненно их чередовать)
multyset - множество, в котором могут встречаться одинаковые по значению ключи.
В приведенной ниже программе на С++ реализованы далеко не все возможные и полезные функции для работы с динамическими массивами, т.к. она создана только для демонстрации принципа создания такого рода массивов.

Определение класса:

template<class T>
class DynamicArray {
      long size;               //размер массива
      long count;              //количество элементов в массиве
      T* p;                    //указатель на начало массива

  public:
      //конструкторы
      DynamicArray(long s = 10): size(s), count(0) {
          p = new T[size];
          if(!p)
             cout << "Ошибка при создании массива" << endl;
      }
      DynamicArray(const DynamicArray& arr);    //конструктор копирования

      //деструктор
      ~DynamicArray() {
          if(p) delete[] p;
      }

      //функции
      void add(T x);                  //прибавить элемент в конец массива
      void remove();                          //удалить последний элемент
      long length() const {return size;}                 //длина массива
      void print() const;                                //вывод на экран

      //операторы
      DynamicArray& operator=(const DynamicArray& arr);  //присваивание
      T operator [] (long i) const;                      //индексация
      DynamicArray& operator+(const DynamicArray& arr);  //сложение
};

Реализация функций и операторов:
//копирующий конструктор
template<class T>
DynamicArray<T>::DynamicArray(const DynamicArray& arr) {
    size = arr.size;
    count = arr.count;
    p = new T[size];
    for(int i = 0; i<count; ++i)
        p[i] = arr.p[i];
}

Здесь возвращаем значение по ссылке, чтобы можно было строить цепочку присваиваний:
template<class T>
DynamicArray<T>&        
DynamicArray<T>::operator=(const DynamicArray& arr)
      if(this != &arr) {       //чтобы избежать присваивания самому себе
         size = arr.size;
         count = arr.count;
         if(p) delete[] p;
         p = new T[size];
         for(int i = 0; i<count; ++i) 
            p[i] = arr.p[i];

     }
     return *this;
}

template<class T>
T DynamicArray<T>::operator[](long i) const {
    if(i < size && i)
        return p[i-1];
    else
        cout << "Неправильный индекс" << endl;
    return 0;
}

template<class T>
DynamicArray<T>& 
DynamicArray<T>::operator+(const DynamicArray& arr) {
    DynamicArray temp(*this);  //сохраняем значения во временном массиве
    if(p) delete[] p;
    size += arr.size;
    count += arr.count;
    p = new T[size];
    for(int i = 0; i<temp.count; ++i)
         p[i] = temp.p[i];
    for(int i = 0; i<arr.count; ++i)
         p[temp.count + i] = arr.p[i];
    return *this;
}

template<class T>
void DynamicArray<T>::print() const {
    cout << "The array contains:" << endl;
    for(int i = 0; i<count; ++i)        
         cout << p[i] << ' ';
    cout << endl;
}

template<class T>
void DynamicArray<T>::add(T x) {
    if(count >= size) {
        //увеличиваем размер массива       
        DynamicArray temp(*this);
        if(p) delete[] p;
        size += 10;
        p = new T[size];
        for(int i = 0; i<temp.count; ++i)
            p[i] = temp.p[i];
    }
    p[count++] = x;           //прибавить элемент в конец массива
}

template<class T>
void DynamicArray<T>::remove() {
   if(count)
       p[--count] = 0;    //удалить последний элемент (если массив
                          //не пустой)
   else
       cout << "Массив пуст" << endl;
}

Добавлено: 21 Сентября 2013 10:39:04 Добавил: Андрей Ковальчук

Класс для отправки сообщений по E-mail

Класс Mail предназначен для отправки сообщений на E-Mail сервер с помощью протокола SMTP (Simple Mail Transfer Protocol).

Конструктор класса

public Mail (string Host, int Port, string User, string Password, string From, string To, string CC = “”, int CodePage = 20866);

Инициализирует параметры соединения с почтовым сервером, который позволяет отправлять сообщения по протоколу SMTP (Simple Mail Transfer Protocol).

Параметры:

Host – имя или IP адрес почтового сервера;
Port – номер порта почтового сервера;
User – имя учетной записи;
Password – пароль учетной записи;
From – адрес отправителя электронной почты;
To – адрес получателя электронной почты;
CC – список адресов получателей копии электронной почты, если список пуст, то передается пустая строка;
CodePage – кодовая страница, определяет кодировку параметров From, To, по умолчанию 20866 (koi8-r).
Формат строки представления адреса получателя и отправителя:

“<E-Mail>[,<DisplayName>]”

Формат строки представления, списка получателей копии электронной почты:
“[<E-Mail[,<E-Mail>, … , <E-Mail>]”

гдеб

E-Mail – адрес электронной почты;
DisplayName - отображаемое имя.
Методы класса

public bool MailSend (string Subject, string Body, string AttachFile)

Отправляет указанное сообщение на сервер SMTP, для доставки получателем.

Параметры:

Body – сообщение;
Subject – тема сообщения;
AttachFile – полное имя вложенного файла в сообщение или пустая строка, если его нет.
Возвращаемый результат:

True – сообщение отправлено успешно или False, если произошла ошибка.
public void MailClose()

Закрывает текущее соединение с почтовым сервером по протоколу SMTP. Освобождает все занятые ресурсы.

Свойства класса

public string Err { get; }

Возвращает строку с сообщением об ошибке, возникшей при отправке почтового сообщения, или пустую строку, если ошибок нет.

Пример использования класса Mail
//****************************************
// Пример использования класса Mail
//****************************************

using System;
using SM;

...

// создаем объект

Mail oSM = new Mail("67.13.256.48", 25, "ssk/cnt_notif", "adm",
 "Sidorov@fsk.sdd,Сидоров Иван Иванович",
 "Petrov@fsk.sdd,Петров Алексей Николаевич");

// отправляем сообщение

if (oSM.MailSend("Тест", "Тестовое сообщение", "d:\test.txt")) 
 Console.WriteLine("Сообщение отправлено");
else
 Console.WriteLine("Ошибка! " + oSM.Err);

// закрываем соединение и освобождаем занятые ресурсы
oSM.MailClose();
...


Код класса
using System;
using System.Net;
using System.Net.Mail;
using System.Net.Mime;


namespace SM {

// Класс для отправки сообщений на E-Mail,
// с помощью протокола SMTP (Simple Mail Transfer Protocol)
public class Mail {
  private SmtpClient Client;
  private MailMessage Message;
  private string Error;

  //*************************************************************
  //* Function: Mail
  //* Notes: Конструктор класса
  //*

  public Mail (string Host, int Port, string User, string Password,
               string From, string To, string CC = "", int CodePage = 20866) {
    int Index = 0;
    MailAddress from;
    MailAddress to;
    NetworkCredential Credentials = new NetworkCredential(User, Password);

    this.Client = new SmtpClient(Host, Port);
    this.Client.Credentials = Credentials;
    Index = From.IndexOf(',');
    if (Index >= 0) {
      from = new MailAddress(From.Substring(0, Index),
                             From.Substring(Index + 1),
                             System.Text.Encoding.GetEncoding(CodePage));
    }
    else {
      from = new MailAddress(From);
    }
    Index = To.IndexOf(',');
    if (Index >= 0) {
      to = new MailAddress(To.Substring(0, Index),
                           To.Substring(Index + 1),
                           System.Text.Encoding.GetEncoding(CodePage));
    }
    else {
      to = new MailAddress(To);
    }
    this.Message = new MailMessage(from, to);
    if (!String.IsNullOrEmpty(CC)) {
      this.Message.CC.Add(CC);
    }
    this.Error = "";
  }

  //*** End of Mail ***********

  //*************************************************************
  //* Function: MailSend
  //* Notes: Отправляет указанное сообщение Body на сервер SMTP для
  //*        доставки получателем.
  //           Subject    - тема сообщения.
  //*          AttachFile - полное имя вложенного файла в сообщение или
  //*                       пустая строка, если его нет.
  //* Функция возвращает true, если сообщение отправлено успешно или false,
  //* в любом другом случае.
  //*

  public bool MailSend (string Subject, string Body, string AttachFile) {
    Attachment data = new Attachment(AttachFile, MediaTypeNames.Text.Plain);

    this.Error = "";
    this.Message.Subject = Subject;
    this.Message.Body = Body;
    this.Message.Attachments.Add(data);
    try {
      this.Client.Send(Message);
    }
    catch (Exception e) {
      this.Error = e.Message;
      return false;
    }
    this.Message.Attachments.Clear();
    return true;
  }

  //*** End of MailSend ***********

  //*************************************************************
  //* Function: MailClose
  //* Notes: Закрывает текущее соединение с почтовым сервером по протоколу SMTP.
  //*        Освобождает все занятые ресурсы.
  //*

  public void MailClose () {
    this.Client = null;
    this.Message.Dispose();
    this.Message = null;
  }

  //*** End of MailClose ***********

  // получить ошибку при передачи сообщения
  public string Err {
    get {
      return this.Error;
    }
  }

}

}

Добавлено: 21 Сентября 2013 02:31:14 Добавил: Андрей Ковальчук