using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using GSF;
using GSF.Adapters;
using GSF.Security.Cryptography;
class Program
{
static AdapterLoader<PublishAdapterBase> s_adapterLoader;
static void Main(string[] args)
{
// Enable app domain resource monitoring.
AppDomain.MonitoringIsEnabled = true;
// Load adapters that mimic data publishing.
s_adapterLoader = new AdapterLoader<PublishAdapterBase>();
s_adapterLoader.IsolateAdapters = true;
s_adapterLoader.MonitorAdapters = true;
s_adapterLoader.AdapterFileExtension = "*.exe";
s_adapterLoader.AllowableProcessMemoryUsage = 200;
s_adapterLoader.AllowableProcessProcessorUsage = 50;
s_adapterLoader.AllowableAdapterMemoryUsage = 100;
s_adapterLoader.AllowableAdapterProcessorUsage = 25;
s_adapterLoader.AdapterLoaded += OnAdapterLoaded;
s_adapterLoader.AdapterUnloaded += OnAdapterUnloaded;
s_adapterLoader.AdapterResourceUsageExceeded += OnAdapterResourceUsageExceeded;
s_adapterLoader.Initialize();
// Shutdown.
Console.ReadLine();
s_adapterLoader.Dispose();
}
static void OnAdapterLoaded(object sender, EventArgs<PublishAdapterBase> e)
{
Console.WriteLine("{0} has been loaded\r\n", e.Argument.GetType().Name);
}
static void OnAdapterUnloaded(object sender, EventArgs<PublishAdapterBase> e)
{
Console.WriteLine("{0} has been unloaded\r\n", e.Argument.GetType().Name);
}
static void OnAdapterResourceUsageExceeded(object sender, GSF.EventArgs<PublishAdapterBase> e)
{
Console.WriteLine("{0} status:", e.Argument.Name);
Console.WriteLine(e.Argument.Status);
// Remove the adapter in order to reclaim the resources used by it.
lock (s_adapterLoader.Adapters)
{
s_adapterLoader.Adapters.Remove(e.Argument);
}
}
}
/// <summary>
/// Base adapter class.
/// </summary>
public abstract class PublishAdapterBase : Adapter
{
public PublishAdapterBase()
{
Data = new List<byte[]>();
}
public List<byte[]> Data { get; set; }
public override void Initialize()
{
base.Initialize();
new Thread(Publish).Start();
}
protected abstract void Publish();
}
/// <summary>
/// Adapter that does not manage memory well.
/// </summary>
public class PublishAdapterA : PublishAdapterBase
{
protected override void Publish()
{
while (true)
{
for (int i = 0; i < 10000; i++)
{
Data.Add(new byte[10]);
}
Thread.Sleep(100);
}
}
}
/// <summary>
/// Adapter that uses the processor in excess.
/// </summary>
public class PublishAdapterB : PublishAdapterBase
{
protected override void Publish()
{
string text = string.Empty;
System.Random random = new System.Random();
while (true)
{
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 4; j++)
{
text += (char)random.Next(256);
}
Data.Add(Encoding.ASCII.GetBytes(text.Encrypt("C1pH3r", CipherStrength.Aes256)).BlockCopy(0, 1));
}
Thread.Sleep(10);
}
}
}
using System;
using System.Collections.Generic;
using GSF.Collections;
using GSF.Validation;
class Program
{
static void Main(string[] args)
{
// Initialize settings.
SettingsCollection settings = "Server=localhost;Port=5000";
// Add validation rules.
settings.Validation.AddValidation("Server", new NonNullStringValidator());
settings.Validation.AddValidation("Port", new NonNullStringValidator());
settings.Validation.AddValidation("Port", new NumericRangeValidator(1000, 2000));
// Validate settings.
string errors;
if (!settings.Validation.Validate(out errors))
{
// Show validation errors.
Console.WriteLine(string.Format("Settings: {0}\r\n", settings));
Console.WriteLine(errors);
}
else
{
// Show stored settings.
foreach (KeyValuePair<string, string> setting in settings)
{
Console.WriteLine(string.Format("Key={0}; Value={1}", setting.Key, setting.Value));
}
}
Console.ReadLine();
}
}
Dim buffer As Byte() = CreateArray(Of Byte)(12)
Dim matrix As Integer()() = CreateArray(Of Integer())(10)
Dim elements As Integer() = CreateArray(12, -1)
Dim names As String() = CreateArray(100, "undefined")
[TypeConvertedValueExpression("Form.maskedTextBoxMessageInterval.Text", typeof(string))]
public int MessageInterval { get; set; }
Would generate an expression of "Common.TypeConvertFromString(Form.maskedTextBoxMessageInterval.Text, typeof(int))"
which would be executed as part of an overall expression that looked like
[TypeConvertedValueExpression("Form.maskedTextBoxMessageInterval.Text", typeof(string))]
public int MessageInterval { get; set; }
Would generate an update expression of "Common.TypeConvertToString(Instance.MessageInterval)"
which would be executed as part of an overall expression that looked like
static MyModel()
{
TableOperations<MyModel>.TypeRegistry.RegisterType<MyType>();
}
public enum MyEnum
{
One,
Two,
Three
}
public class MySettings : AppSettingsBase
{
// Private property fields (private fields will not be serialized)
private double m_doubleVal;
// Public settings fields
public bool BoolVal = true;
public int IntVal = 1;
public float FloatVal = 3.14F;
public string StrVal = "This is a test...";
public MyEnum EnumVal = MyEnum.Three;
[SettingName("UserOptions"), EncryptSetting()]
public string Password = "default";
// Mark this field to not be serialized to INI file...
[SerializeSetting(false)]
public decimal DecimalVal;
[Category("OtherSettings"), DefaultValue(1.159D)]
public double DoubleVal
{
get
{
return m_doubleVal;
}
set
{
m_doubleVal = value;
}
}
[SerializeSetting(false)]
public bool DontSerializeMe { get; set; }
}
public enum MyEnum
{
One,
Two,
Three
}
public class MySettings : CategorizedSettingsBase
{
// Private property fields (private fields will not be serialized)
private double m_doubleVal;
// Public settings fields
public bool BoolVal = true;
public int IntVal = 1;
public float FloatVal = 3.14F;
public string StrVal = "This is a test...";
public MyEnum EnumVal = MyEnum.Three;
[SettingName("UserOptions"), EncryptSetting()]
public string Password = "default";
// Mark this field to not be serialized to configuration file...
[SerializeSetting(false)]
public decimal DecimalVal;
public MySettings()
: base("GeneralSettings") {}
[Category("OtherSettings"), Description("My double value setting description."), DefaultValue(1.159D)]
public double DoubleVal
{
get
{
return m_doubleVal;
}
set
{
m_doubleVal = value;
}
}
[SerializeSetting(false)]
public bool DontSerializeMe { get; set; }
}
]]>
using System;
using System.Configuration;
using GSF;
using GSF.Configuration;
class Program
{
static void Main(string[] args)
{
// Get the application config file.
ConfigurationFile config = ConfigurationFile.Current;
// Get the sections of config file.
CategorizedSettingsElementCollection startup = config.Settings["Startup"];
CategorizedSettingsElementCollection passwords = config.Settings["Passwords"];
CategorizedSettingsElementCollection monitoring = config.Settings["Monitoring"];
KeyValueConfigurationCollection appSettings = config.Configuration.AppSettings.Settings;
ConnectionStringSettingsCollection connStrings = config.Configuration.ConnectionStrings.ConnectionStrings;
// Add settings to the config file under the "appSettings" section.
appSettings.Add("SaveSettingOnExit", true.ToString());
// Add settings to the config file under the "connectionStrings" section.
connStrings.Add(new ConnectionStringSettings("DevSql", "Server=SqlServer;Database=Sandbox;Trusted_Connection=True"));
// Add settings to the config (if they don't exist) under a custom "monitoring" section.
monitoring.Add("RefreshInterval", 5, "Interval in seconds at which the Monitor screen is to be refreshed.");
monitoring.Add("MessagesSnapshot", 30000, "Maximum messages length to be displayed on the Monitor screen.");
// Add password to the config file encrypted (if it doesn't exist) under a custom "passwords" section.
passwords.Add("Admin", "Adm1nP4ss", "Password used for performing administrative tasks.", true);
// Add user-scope setting to the config (if it doesn't exist) under a custom "startup" section.
startup.Add("Theme", "Default", "Application theme to use for the session.", false, SettingScope.User);
config.Save(); // Save settings to the config file.
// Read saved settings from the config file.
bool saveSettingsOnExit = appSettings["SaveSettingOnExit"].Value.ParseBoolean();
string devConnectionString = connStrings["DevSql"].ConnectionString;
string appTheme = startup["Theme"].Value;
string adminPassword = passwords["Admin"].Value;
int refreshInterval = monitoring["RefreshInterval"].ValueAsInt32();
int messagesSnapshot = monitoring["MessagesSnapshot"].ValueAsInt32();
// Print the retrieved settings to the console.
Console.WriteLine("SaveSettingOnExit = {0}", saveSettingsOnExit);
Console.WriteLine("DevSql = {0}", devConnectionString);
Console.WriteLine("Theme = {0}", appTheme);
Console.WriteLine("Admin = {0}", adminPassword);
Console.WriteLine("RefreshInterval = {0}", refreshInterval);
Console.WriteLine("MessagesSnapshot = {0}", messagesSnapshot);
Console.ReadLine();
}
}
This example shows the content of the config file from the sample code above:
]]>
public enum MyEnum
{
One,
Two,
Three
}
public class MySettings : IniSettingsBase
{
// Private property fields (private fields will not be serialized)
private double m_doubleVal;
// Public settings fields
public bool BoolVal = true;
public int IntVal = 1;
public float FloatVal = 3.14F;
public string StrVal = "This is a test...";
public MyEnum EnumVal = MyEnum.Three;
[SettingName("UserOptions"), EncryptSetting()]
public string Password = "default";
// Mark this field to not be serialized to INI file...
[SerializeSetting(false)]
public decimal DecimalVal;
public MySettings()
: base(FilePath.GetAbsolutePath("MySettings.ini"), "GeneralSettings") {}
[Category("OtherSettings"), DefaultValue(1.159D)]
public double DoubleVal
{
get
{
return m_doubleVal;
}
set
{
m_doubleVal = value;
}
}
[SerializeSetting(false)]
public bool DontSerializeMe { get; set; }
}
public enum MyEnum
{
One,
Two,
Three
}
public class MySettings : RegistrySettingsBase
{
// Private property fields (private fields will not be serialized)
private double m_doubleVal;
// Public settings fields
public bool BoolVal = true;
public int IntVal = 1;
public float FloatVal = 3.14F;
public string StrVal = "This is a test...";
public MyEnum EnumVal = MyEnum.Three;
[SettingName("UserOptions"), EncryptSetting()]
public string Password = "default";
// Mark this field to not be serialized to registry...
[SerializeSetting(false)]
public decimal DecimalVal;
public MySettings()
: base("HKEY_CURRENT_USER\\Software\\My Company\\My Product\\", "General Settings") {}
[Category("OtherSettings"), DefaultValue(1.159D)]
public double DoubleVal
{
get
{
return m_doubleVal;
}
set
{
m_doubleVal = value;
}
}
[SerializeSetting(false)]
public bool DontSerializeMe { get; set; }
}
using System;
using GSF;
using GSF.Console;
class Program
{
static void Main()
{
Arguments args = new Arguments("Sample.txt -wrap=true");
string file = args["OrderedArg1"];
bool wrapText = args["wrap"].ParseBoolean();
Console.WriteLine(string.Format("File: {0}", file));
Console.WriteLine(string.Format("Wrap text: {0}", wrapText));
Console.ReadLine();
}
}
This example shows how to parse a command-line command that contains an executable name in it:
using System;
using GSF.Console;
class Program
{
static void Main()
{
// Environment.CommandLine = @"""c:\program files\tva\theme application\app.exe"" Document1.dcx -theme=default"
Arguments args = new Arguments(Environment.CommandLine, true);
string doc = args["OrderedArg1"];
string theme = args["theme"];
Console.WriteLine(string.Format("Document: {0}", doc));
Console.WriteLine(string.Format("Application theme: {0}", theme));
Console.ReadLine();
}
}
using System;
using GSF.Console;
class Program
{
static void Main(string[] args)
{
// Subscribe to console events.
Events.CancelKeyPress += Events_CancelKeyPress;
Events.ConsoleClosing += Events_ConsoleClosing;
Events.EnableRaisingEvents();
Console.ReadLine();
}
static void Events_CancelKeyPress(object sender, System.ComponentModel.CancelEventArgs e)
{
// Abort processing.
}
static void Events_ConsoleClosing(object sender, System.ComponentModel.CancelEventArgs e)
{
// Put clean-up code.
}
}
]]>
[AmendExpression("AS T1", DatabaseType.SQLServer), AmendExpression("AS T1", DatabaseType.MySQL)]
Other parameters exist to fully customize target expression, set affix position and specify statement types:
[AmendExpression("TOP 200",
TargetExpression = TargetExpression.FieldList,
AffixPosition = AffixPosition.Prefix,
StatementTypes = StatementTypes.SelectSet)]
restriction = RootQueryRestriction + restriction;
A root query restriction is useful to apply a common state to the query operations, e.g., always
filtering records for a specific user or context.
[AmendExpression("TOP {count}",
TargetExpression = TargetExpression.FieldList,
AffixPosition = AffixPosition.Prefix,
StatementTypes = StatementTypes.SelectSet)]]
The
int count = 200;
customTokens = new[] { new KeyValuePair<string, string>("{count}", $"{count}") };
[AmendExpression("TOP {count}",
TargetExpression = TargetExpression.FieldList,
AffixPosition = AffixPosition.Prefix,
StatementTypes = StatementTypes.SelectSet)]]
The
int count = 200;
customTokens = new[] { new KeyValuePair<string, string>("{count}", $"{count}") };
using System;
using System.Threading;
using GSF.Diagnostics;
class Program
{
static void Main(string[] args)
{
PerformanceCounter counter = new PerformanceCounter("Processor", "% Processor Time", "_Total");
while (true)
{
Thread.Sleep(1000);
counter.Sample();
Console.WriteLine(string.Format("Last value: {0}", counter.LastValue));
Console.WriteLine(string.Format("Minimum value: {0}", counter.MinimumValue));
Console.WriteLine(string.Format("Maximum value: {0}", counter.MaximumValue));
Console.WriteLine(string.Format("Average value: {0}", counter.AverageValue));
Console.WriteLine(new string('-', 30));
}
}
}
using System;
using System.Threading;
using GSF.Diagnostics;
class Program
{
static void Main(string[] args)
{
PerformanceMonitor perfMon = new PerformanceMonitor();
while (true)
{
// Display process performance.
Thread.Sleep(5000);
Console.WriteLine("");
Console.Write(perfMon.Status);
}
}
}
using System;
using GSF.Drawing;
using System.Drawing;
class Program
{
static void Main(string[] args)
{
// Load the original image.
Bitmap original = (Bitmap)Bitmap.FromFile("Original.jpg");
// Resize the original image.
Bitmap originalResized = original.Resize(new Size(800, 600));
// Save the resized image to file.
originalResized.Save("OriginalResized.jpg");
// Clean-up.
original.Dispose();
originalResized.Dispose();
Console.ReadLine();
}
}
using System;
using System.Drawing;
using GSF.Drawing;
class Program
{
static void Main(string[] args)
{
// Load original, resize it, and dispose original.
using (Bitmap resized = ((Bitmap)Bitmap.FromFile("Original.jpg")).Resize(new Size(800, 600), true))
{
// Save the resized image to file.
resized.Save("OriginalResized.jpg");
}
Console.ReadLine();
}
}
using System;
using System.Drawing;
using GSF.Drawing;
class Program
{
static void Main(string[] args)
{
// Load the original image.
Bitmap original = (Bitmap)Bitmap.FromFile("Original.jpg");
// Crop the original image.
Bitmap originalCropped = original.Crop(new Rectangle(0, 0, 300, 300));
// Save the cropped image to file.
originalCropped.Save("OriginalCropped.jpg");
// Clean-up.
original.Dispose();
originalCropped.Dispose();
Console.ReadLine();
}
}
using System;
using System.Drawing;
using GSF.Drawing;
class Program
{
static void Main(string[] args)
{
// Load original, crop it, and dispose original.
using (Bitmap cropped = ((Bitmap)Bitmap.FromFile("Original.jpg")).Crop(new Rectangle(0, 0, 300, 300), true))
{
// Save the cropped image to file.
cropped.Save("OriginalCropped.jpg");
}
Console.ReadLine();
}
}
using System;
using System.Drawing;
using System.Drawing.Imaging;
using GSF.Drawing;
class Program
{
static void Main(string[] args)
{
// Load the original image.
Bitmap original = (Bitmap)Bitmap.FromFile("Original.jpg");
// Convert the original image.
Bitmap originalGif = original.ConvertTo(ImageFormat.Gif);
// Save the converted image to file.
originalGif.Save("OriginalGif.gif");
// Clean-up.
original.Dispose();
originalGif.Dispose();
Console.ReadLine();
}
}
using System;
using System.Drawing;
using System.Drawing.Imaging;
using GSF.Drawing;
class Program
{
static void Main(string[] args)
{
// Load original, convert it, and dispose original.
using (Bitmap converted = ((Bitmap)Bitmap.FromFile("Original.jpg")).ConvertTo(ImageFormat.Gif))
{
// Save the converted image to file.
converted.Save("OriginalGif.gif");
}
Console.ReadLine();
}
}
using System;
using System.IO;
using GSF.ErrorManagement;
class Program
{
static ErrorLogger s_logger;
static Program()
{
s_logger = new ErrorLogger();
s_logger.LogToUI = true; // Show exception info on the UI.
s_logger.LogToFile = true; // Log exception info to a file.
s_logger.LogToEmail = true; // Send exception info in an e-mail.
s_logger.LogToEventLog = true; // Log exception info to the event log.
s_logger.ContactEmail = "dev@email.com"; // Provide an e-mail address.
s_logger.HandleUnhandledException = true; // Configure to handle unhandled exceptions.
s_logger.PersistSettings = true; // Save settings to the config file.
s_logger.Initialize(); // Initialize ErrorLogger component for use.
}
static void Main(string[] args)
{
try
{
// This may cause a handled FileNotFoundException if the file doesn't exist.
string data = File.ReadAllText(@"c:\NonExistentFile.txt");
}
catch (Exception ex)
{
// When logging handled exceptions we want to disable loggers (UI logger and E-mail logger) that
// may require interaction either directly or indirectly as it can be annoying. All the loggers
// are enabled automatically after the handled exception has been logged.
s_logger.SuppressInteractiveLogging();
s_logger.Log(ex);
}
int numerator = 1;
int denominator = 0;
int result = numerator / denominator; // This will cause an unhandled DivideByZeroException.
Console.ReadLine();
}
}
]]>
Below is the config file entry required for changing the settings of
]]>
using System;
using GSF.ErrorManagement;
namespace WebApp
{
public partial class _Default : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
try
{
string s = null;
s.ToCharArray(); // This will result in NullReferenceException.
}
catch (Exception ex)
{
ErrorModule.Logger.Log(ex); // Log the encountered exception.
}
}
}
}
]]>
using System;
using GSF.Identity;
class Program
{
static void Main(string[] args)
{
// Retrieve and display user information from Active Directory.
using (UserInfo user = new UserInfo("XYZCorp\\johndoe"))
{
Console.WriteLine(string.Format("First Name: {0}", user.FirstName));
Console.WriteLine(string.Format("Last Name: {0}", user.LastName));
Console.WriteLine(string.Format("Middle Initial: {0}", user.MiddleInitial));
Console.WriteLine(string.Format("Email Address: {0}", user.Email));
Console.WriteLine(string.Format("Telephone Number: {0}", user.Telephone));
}
Console.ReadLine();
}
}
This example shows the config file section that can be used to specify the domain account to be used for Active Directory queries:
]]>
AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal);
using System;
using GSF.Identity;
class Program
{
static void Main(string[] args)
{
using (UserInfo user = new UserInfo("XYZCorp\\johndoe"))
{
// Define the identity to use for retrieving Active Directory information.
// Persist identity credentials encrypted to the config for easy access.
user.PersistSettings = true;
user.DefinePrivilegedAccount("XYZCorp", "admin", "Passw0rd");
// Retrieve and display user information from Active Directory.
Console.WriteLine(string.Format("First Name: {0}", user.FirstName));
Console.WriteLine(string.Format("Last Name: {0}", user.LastName));
Console.WriteLine(string.Format("Middle Initial: {0}", user.MiddleInitial));
Console.WriteLine(string.Format("Email Address: {0}", user.Email));
Console.WriteLine(string.Format("Telephone Number: {0}", user.Telephone));
}
Console.ReadLine();
}
}
using System;
using GSF.Identity;
class Program
{
static void Main(string[] args)
{
string domain = "XYZCorp";
string username = "johndoe";
string password = "password";
// Authenticate user credentials.
if (UserInfo.AuthenticateUser(domain, username, password) is not null)
Console.WriteLine("Successfully authenticated user \"{0}\\{1}\".", domain, username);
else
Console.WriteLine("Failed to authenticate user \"{0}\\{1}\".", domain, username);
Console.ReadLine();
}
}
using System;
using GSF.Identity;
class Program
{
static void Main(string[] args)
{
string domain = "XYZCorp";
string username = "johndoe";
string password = "password";
string errorMessage;
// Authenticate user credentials.
if (UserInfo.AuthenticateUser(domain, username, password, out errorMessage) is not null)
Console.WriteLine("Successfully authenticated user \"{0}\\{1}\".", domain, username);
else
Console.WriteLine("Failed to authenticate user \"{0}\\{1}\" due to exception: {2}", domain, username, errorMessage);
Console.ReadLine();
}
}
using System;
using GSF.Identity;
class Program
{
static void Main(string[] args)
{
Console.WriteLine(string.Format("User before impersonation: {0}", UserInfo.CurrentUserID));
UserInfo.ImpersonateUser("XYZCorp", "johndoe", "password"); // Impersonate user.
Console.WriteLine(string.Format("User after impersonation: {0}", UserInfo.CurrentUserID));
Console.ReadLine();
}
}
using System;
using System.IO;
using System.Security.Principal;
using GSF.Identity;
class Program
{
static void Main(string[] args)
{
// Impersonate user.
WindowsImpersonationContext context = UserInfo.ImpersonateUser("XYZCorp", "johndoe", "password");
// Perform operation requiring elevated privileges.
Console.WriteLine(File.ReadAllText(@"\\server\share\file.xml"));
// End the impersonation.
UserInfo.EndImpersonation(context);
Console.ReadLine();
}
}
using (StreamReader reader = GetFileLock(File.OpenText))
{
// Read lines from the file
}
using (FileStream stream = GetFileLock(File.Create))
{
// Write bytes into the file
}
using System;
using System.Text;
using GSF;
using GSF.IO;
using GSF.Parsing;
class Program
{
static void Main(string[] args)
{
// Create a few test records.
TestIsamFileRecord r1 = new TestIsamFileRecord(1);
r1.Name = "TestRecord1";
r1.Value = double.MinValue;
r1.Description = "Test record with minimum double value";
TestIsamFileRecord r2 = new TestIsamFileRecord(2);
r2.Name = "TestRecord2";
r2.Value = double.MaxValue;
r2.Description = "Test record with maximum double value";
// Open ISAM file.
TestIsamFile testFile = new TestIsamFile();
testFile.FileName = "TestIsamFile.dat";
testFile.Open();
// Write test records.
testFile.Write(r1.Index, r1);
testFile.Write(r2.Index, r2);
// Read test records.
Console.WriteLine(testFile.Read(1));
Console.WriteLine(testFile.Read(2));
// Close ISAM file.
testFile.Close();
Console.ReadLine();
}
}
class TestIsamFile : IsamDataFileBase<TestIsamFileRecord>
{
///
/// Size of a single file record.
///
protected override int GetRecordSize()
{
return TestIsamFileRecord.RecordLength;
}
///
/// Creates a new empty file record.
///
protected override TestIsamFileRecord CreateNewRecord(int id)
{
return new TestIsamFileRecord(id);
}
}
class TestIsamFileRecord : ISupportBinaryImage
{
private int m_index;
private string m_name; // 20 * 1 = 20
private double m_value; // 1 * 8 = 8
private string m_description; // 100 * 1 = 100
public const int RecordLength = 128; // Total = 128
public TestIsamFileRecord(int recordIndex)
{
m_index = recordIndex;
Name = string.Empty;
Value = double.NaN;
Description = string.Empty;
}
///
/// 1-based index of the record.
///
public int Index
{
get { return m_index; }
}
///
/// Name of the record.
///
public string Name
{
get { return m_name; }
set { m_name = value.TruncateRight(20).PadRight(20); }
}
///
/// Value of the record.
///
public double Value
{
get { return m_value; }
set { m_value = value; }
}
///
/// Description of the record.
///
public string Description
{
get { return m_description; }
set { m_description = value.TruncateRight(100).PadRight(100); }
}
///
/// Serialized record length.
///
public int BinaryLength
{
get { return RecordLength; }
}
///
/// Serialized record data.
///
public byte[] BinaryImage
{
get
{
// Serialize TestIsamFileRecord into byte array.
byte[] image = new byte[RecordLength];
Buffer.BlockCopy(Encoding.ASCII.GetBytes(Name), 0, image, 0, 20);
Buffer.BlockCopy(BitConverter.GetBytes(Value), 0, image, 20, 8);
Buffer.BlockCopy(Encoding.ASCII.GetBytes(Description), 0, image, 28, 100);
return image;
}
}
///
/// Deserializes the record.
///
public int Initialize(byte[] binaryImage, int startIndex, int length)
{
if (length >= RecordLength)
{
// Deserialize byte array into TestIsamFileRecord.
Name = Encoding.ASCII.GetString(binaryImage, startIndex, 20);
Value = BitConverter.ToDouble(binaryImage, startIndex + 20);
Description = Encoding.ASCII.GetString(binaryImage, startIndex + 28, 100);
}
else
throw new InvalidOperationException("Invalid record size, not enough data to deserialize record");
return RecordLength;
}
///
/// String representation of the record.
///
public override string ToString()
{
return string.Format("Name: {0}, Value: {1}, Description: {2}", Name, Value, Description);
}
}
using System;
using GSF.IO;
class Program
{
static void Main(string[] args)
{
LogFile log = new LogFile();
log.Initialize(); // Initialize the log file.
log.Open(); // Open the log file.
log.WriteTimestampedLine("Test entry"); // Write message to the log file.
log.Flush(); // Flush message to the log file.
log.Close(); // Close the log file.
Console.ReadLine();
}
}
using System;
using GSF.IO;
class Program
{
static MultipleDestinationExporter s_exporter;
static void Main(string[] args)
{
s_exporter = new MultipleDestinationExporter();
s_exporter.Initialized += s_exporter_Initialized;
ExportDestination[] defaultDestinations = new ExportDestination[]
{
new ExportDestination(@"\\server1\share\exportFile.txt", false, "domain", "user1", "password1"),
new ExportDestination(@"\\server2\share\exportFile.txt", false, "domain", "user2", "password2")
};
// Initialize with the destinations where data is to be exported.
s_exporter.Initialize(defaultDestinations);
Console.ReadLine();
}
static void s_exporter_Initialized(object sender, EventArgs e)
{
// Export data to all defined locations after initialization.
s_exporter.ExportData("TEST DATA");
}
}
This example shows the config file entry that can be used to specify the
using System;
using GSF.Net.Smtp;
class Program
{
static void Main(string[] args)
{
Mail email = new Mail("sender@email.com", "recipient@email.com", "smtp.email.com");
email.Subject = "Test Message";
email.Body = "This is a test message.";
email.IsBodyHtml = true;
email.Attachments = @"c:\attachment.txt";
email.Send();
email.Dispose();
Console.ReadLine();
}
}
term[i] = Coefficients[i] * Math.Pow(x - XValue, i);
Func<double, double> piecewiseLinearFunc = new PiecewiseLinearFunction()
.SetDomain(-1, 0, 1)
.SetRange(0, 1, 0);
Console.WriteLine(piecewiseLinearFunc(-10)); // -9
Console.WriteLine(piecewiseLinearFunc(-1)); // 0
Console.WriteLine(piecewiseLinearFunc(-0.5)); // 0.5
Console.WriteLine(piecewiseLinearFunc(0)); // 1
Console.WriteLine(piecewiseLinearFunc(0.5)); // 0.5
Console.WriteLine(piecewiseLinearFunc(1)); // 0
Console.WriteLine(piecewiseLinearFunc(10)); // -9
public CommonHeader(object state, byte[] binaryImage, int startIndex, int length)
{
if (length > 3)
{
TypeID = LittleEndian.ToInt32(binaryImage, startIndex);
State = state;
}
else
throw new InvalidOperationException("Malformed image");
}
{CompanyAcronym}_{DeviceAcronym}[?{SignalType.Source}=Phasor[-{SignalType.Suffix}{SignalIndex}]]:{Signal.Acronymn}
then replace the tokens with actual values and properly evaluate the expressions.
Example results could look like: GPA_SHELBY-PA1:IPHA and GPA_SHELBY:FREQ
eval{'{CompanyAcronym}'.Substring(0,3)}_{DeviceAcronym}eval{'[?{SignalType.Source}=Phasor[-{SignalType.Suffix}]]'.Length}
[CanBeNull] public object Test() { return null; }
public void UseTest() {
var p = Test();
var s = p.ToString(); // Warning: Possible 'System.NullReferenceException'
}
[NotNull] public object Foo() {
return null; // Warning: Possible 'null' assignment
}
[StringFormatMethod("message")]
public void ShowError(string message, params object[] args) { /* do something */ }
public void Foo() {
ShowError("Failed: {0}"); // Warning: Non-existing argument in format string
}
public void Foo(string param) {
if (param == null)
throw new ArgumentNullException("par"); // Warning: Cannot resolve symbol
}
public class Foo : INotifyPropertyChanged {
public event PropertyChangedEventHandler PropertyChanged;
[NotifyPropertyChangedInvocator]
protected virtual void NotifyChanged(string propertyName) { ... }
private string _name;
public string Name {
get { return _name; }
set { _name = value; NotifyChanged("LastName"); /* Warning */ }
}
}
Examples of generated notifications:
Function Definition Table syntax:
[ContractAnnotation("=> halt")]
public void TerminationMethod()
[ContractAnnotation("halt <= condition: false")]
public void Assert(bool condition, string text) // regular assertion method
[ContractAnnotation("s:null => true")]
public bool IsNullOrEmpty(string s) // string.IsNullOrEmpty()
// A method that returns null if the parameter is null, and not null if the parameter is not null
[ContractAnnotation("null => null; notnull => notnull")]
public object Transform(object data)
[ContractAnnotation("s:null=>false; =>true,result:notnull; =>false, result:null")]
public bool TryParse(string s, out Person result)
[LocalizationRequiredAttribute(true)]
public class Foo {
private string str = "my string"; // Warning: Localizable string
}
[CannotApplyEqualityOperator]
class NoEquality { }
class UsesNoEquality {
public void Test() {
var ca1 = new NoEquality();
var ca2 = new NoEquality();
if (ca1 != null) { // OK
bool condition = ca1 == ca2; // Warning
}
}
}
[BaseTypeRequired(typeof(IComponent)] // Specify requirement
public class ComponentAttribute : Attribute { }
[Component] // ComponentAttribute requires implementing IComponent interface
public class MyComponent : IComponent { }
[Pure] private int Multiply(int x, int y) { return x * y; }
public void Foo() {
const int a = 2, b = 2;
Multiply(a, b); // Waring: Return value of pure method is not used
}
[ActionName("Foo")]
public ActionResult Login(string returnUrl) {
ViewBag.ReturnUrl = Url.Action("Foo"); // OK
return RedirectToAction("Bar"); // Error: Cannot resolve action
}
/// <summary>
/// Class that shows example implementation of reusable <see cref="ISupportLifecycle"/>.
/// </summary>
public class ReusableClass : ISupportLifecycle
{
#region [ Members ]
// Events
/// <summary>
/// Occurs when the <see cref="ReusableClass"/> is disposed.
/// </summary>
public event EventHandler Disposed;
// Fields
private System.Timers.Timer m_timer; // Example member variable that needs initialization and disposal
private bool m_enabled;
private bool m_disposed;
#endregion
#region [ Constructors ]
/// <summary>
/// Releases the unmanaged resources before the <see cref="ReusableClass"/> object is reclaimed by <see cref="GC"/>.
/// </summary>
~ReusableClass()
{
Dispose(false);
}
#endregion
#region [ Properties ]
/// <summary>
/// Gets or sets a boolean value that indicates whether the <see cref="ReusableClass"/> object is currently enabled.
/// </summary>
public bool Enabled
{
get
{
return m_enabled;
}
set
{
m_enabled = value;
if (m_timer != null)
m_timer.Enabled = m_enabled;
}
}
#endregion
#region [ Methods ]
/// <summary>
/// Initializes the <see cref="ReusableClass"/> object.
/// </summary>
public void Initialize()
{
// Undispose class instance if it is being reused
if (m_disposed)
{
m_disposed = false;
GC.ReRegisterForFinalize(this);
}
m_enabled = true;
// Initialize member variables
if (m_timer == null)
{
m_timer = new System.Timers.Timer(2000.0D);
m_timer.Elapsed += m_timer_Elapsed;
m_timer.Enabled = m_enabled;
}
}
/// <summary>
/// Releases all the resources used by the <see cref="ReusableClass"/> object.
/// </summary>
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
/// <summary>
/// Releases the unmanaged resources used by the <see cref="ReusableClass"/> object and optionally releases the managed resources.
/// </summary>
/// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
protected virtual void Dispose(bool disposing)
{
if (!m_disposed)
{
try
{
if (disposing)
{
// Dispose member variables
if (m_timer != null)
{
m_timer.Elapsed -= m_timer_Elapsed;
m_timer.Dispose();
}
m_timer = null;
m_enabled = false;
}
}
finally
{
m_disposed = true;
if (Disposed != null)
Disposed(this, EventArgs.Empty);
}
}
}
// Handle timer event
private void m_timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
// Do work here...
}
#endregion
}
+---------------- minute (0 - 59)
| +------------- hour (0 - 23)
| | +---------- day of month (1 - 31)
| | | +------- month (1 - 12)
| | | | +---- day of week (0 - 7) (Sunday=0 or 7)
| | | | |
* * * * *
using System;
using GSF;
using GSF.Scheduling;
class Program
{
static void Main(string[] args)
{
ScheduleManager scheduler = new ScheduleManager();
scheduler.Initialize();
// Add event handlers.
scheduler.Starting += scheduler_Starting;
scheduler.Started += scheduler_Started;
scheduler.ScheduleDue += scheduler_ScheduleDue;
// Add test schedules.
scheduler.AddSchedule("Run.Notepad", "* * * * *");
scheduler.AddSchedule("Run.Explorer", "* * * * *");
// Start the scheduler.
scheduler.Start();
Console.ReadLine();
}
static void scheduler_Started(object sender, EventArgs e)
{
Console.WriteLine("Scheduler has started successfully.");
}
static void scheduler_Starting(object sender, EventArgs e)
{
Console.WriteLine("Scheduler is waiting to be started.");
}
static void scheduler_ScheduleDue(object sender, EventArgsSchedule]]> e)
{
Console.WriteLine(string.Format("{0} schedule is due for processing.", e.Argument.Name));
}
}
string format = "{hello} {world}!";
var parameters = new { hello = "Hello", world = "World" };
Console.WriteLine(format.Interpolate(parameters));
IEnumerable{KeyValuePair{string, object}},
this function will skip the reflection and call
string format = "{hello} {world}!";
dynamic parameters = new ExpandoObject();
parameters.hello = "Hello";
parameters.world = "World";
Console.WriteLine(format.Interpolate(parameters)); // This raises a compiler error
Console.WriteLine(format.Interpolate((ExpandoObject)parameters); // This is okay
Console.WriteLine(StringExtensions.Interpolate(format, parameters); // This is also okay
LogicalThread thread1 = new LogicalThread();
LogicalThread thread2 = new LogicalThread();
// Create logical thread operation with manually controlled call to RunIfPending
LogicalThreadOperation operation = new LogicalThreadOperation(thread1, DoOperation, false);
private void DoOperation()
{
ExecuteOnThread1();
thread2.Push(() => operation.ExecuteAction(() =>
{
ExecuteOnThread2();
operation.RunIfPending();
}));
});
protected override void ExecuteActionAsync()
{
Thread actionThread = new Thread(() =>
{
while (ExecuteAction())
{
}
});
actionThread.Start();
}
public class MyClass
{
private Trackable<string> m_trackableText = new Trackable<string>(nameof(Text), true);
public string Text
{
get
{
return m_trackableText.CurrentValue;
}
set
{
m_trackableText.CurrentValue = value;
}
}
}
using System;
using System.Collections.Generic;
using GSF.Validation;
class Program
{
static void Main(string[] args)
{
// Dictionary where captured user input is saved.
Dictionary<string, string> input = new Dictionary<string, string>();
// Validation service that will validate user input.
ValidationService validation = new ValidationService(delegate(string source)
{
string value;
if (input.TryGetValue(source, out value))
return input[source];
else
return string.Empty;
});
// Add validation rules to the validation service.
validation.AddValidation("Name", new NonNullStringValidator());
validation.AddValidation("Email", new EmailAddressValidator());
// Capture user input.
Console.Write("Enter name: ");
input["Name"] = Console.ReadLine();
Console.Write("Enter email: ");
input["Email"] = Console.ReadLine();
Console.WriteLine("");
// Validate user input.
string errors;
if (!validation.Validate(out errors))
Console.WriteLine(errors);
else
Console.WriteLine("No validation errors were found!");
Console.ReadLine();
}
}
var globals = XDocument.Load(configFile)
.Descendants("SettingsGroup")
.WhereAttribute("Type").Is("Globals");
var globals = XDocument.Load(configFile)
.Descendants("SettingsGroup")
.WhereAttribute("Type").Is("Globals");
public double GetGrads(double degrees)
{
return Angle.FromDegrees(degrees).ToGrads();
}
public double GetKilocoulombs(Charge coulombs)
{
return coulombs / SI.Kilo;
}
public double GetKiloamperes(Current amperes)
{
return amperes / SI.Kilo;
}
public double GetMegajoules(Energy joules)
{
return joules / SI.Mega;
}
This example converts megajoules to kilowatt-hours:
public double GetKilowattHours(double megajoules)
{
return (new Energy(megajoules * SI.Mega)).ToWattHours() / SI.Kilo;
}
This example converts kilowatt-hours to megawatt-hours:
public double GetMegawattHours(double kilowattHours)
{
return (kilowattHours * SI.Kilo) / SI.Mega;
}
public double GetKilometers(Length meters)
{
return meters / SI.Kilo;
}
This example converts feet to inches:
public double GetFeet(double inches)
{
return Length.FromInches(inches).ToFeet();
}
public double GetGrams(Mass kilograms)
{
return kilograms * SI.Kilo;
}
This example converts tons to pounds:
public double GetPounds(double tons)
{
return Mass.FromTons(tons).ToPounds();
}
public double GetMegawatts(Power watts)
{
return watts / SI.Mega;
}
This example converts megawatts to mechanical horsepower:
public double GetHorsepower(double megawatts)
{
return (new Power(megawatts * SI.Mega)).ToHorsepower();
}
public double GetKilometersPerHour(double milesPerHour)
{
return Speed.FromMilesPerHour(milesPerHour).ToKilometersPerHour();
}
public double GetFahrenheit(double celsius)
{
return Temperature.FromCelsius(celsius).ToFahrenheit();
}
public Time GetSeconds(double nanoseconds)
{
return nanoseconds * SI.Nano;
}
Convert time in seconds to milliseconds:
public double GetMilliseconds(Time seconds)
{
return time / SI.Milli;
}
This example converts minutes to hours:
public double GetHours(double minutes)
{
return Time.FromMinutes(minutes).ToHours();
}
public double GetMegavolts(Voltage volts)
{
return volts / SI.Mega;
}
public double GetCubicKilometers(Volume cubicmeters)
{
return cubicmeters / SI.Kilo;
}
This example converts teaspoons to cups:
public double GetCups(double teaspoons)
{
return Volume.FromTeaspoons(teaspoons).ToCups();
}
This example converts liters to fluid ounces:
public double GetFluidOunces(double liters)
{
return Volume.FromLiters(liters).ToFluidOunces();
}
using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
{
using (var raw = System.IO.File.Create(fileToCompress + ".deflated"))
{
using (Stream compressor = new DeflateStream(raw, CompressionMode.Compress))
{
byte[] buffer = new byte[WORKING_BUFFER_SIZE];
int n;
while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
{
compressor.Write(buffer, 0, n);
}
}
}
}
Using input As Stream = File.OpenRead(fileToCompress)
Using raw As FileStream = File.Create(fileToCompress & ".deflated")
Using compressor As Stream = New DeflateStream(raw, CompressionMode.Compress)
Dim buffer As Byte() = New Byte(4096) {}
Dim n As Integer = -1
Do While (n <> 0)
If (n > 0) Then
compressor.Write(buffer, 0, n)
End If
n = input.Read(buffer, 0, buffer.Length)
Loop
End Using
End Using
End Using
using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
{
using (var raw = System.IO.File.Create(fileToCompress + ".deflated"))
{
using (Stream compressor = new DeflateStream(raw,
CompressionMode.Compress,
CompressionLevel.BestCompression))
{
byte[] buffer = new byte[WORKING_BUFFER_SIZE];
int n= -1;
while (n != 0)
{
if (n > 0)
compressor.Write(buffer, 0, n);
n= input.Read(buffer, 0, buffer.Length);
}
}
}
}
Using input As Stream = File.OpenRead(fileToCompress)
Using raw As FileStream = File.Create(fileToCompress & ".deflated")
Using compressor As Stream = New DeflateStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression)
Dim buffer As Byte() = New Byte(4096) {}
Dim n As Integer = -1
Do While (n <> 0)
If (n > 0) Then
compressor.Write(buffer, 0, n)
End If
n = input.Read(buffer, 0, buffer.Length)
Loop
End Using
End Using
End Using
using (var output = System.IO.File.Create(fileToCompress + ".deflated"))
{
using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
{
using (Stream compressor = new DeflateStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, true))
{
byte[] buffer = new byte[WORKING_BUFFER_SIZE];
int n= -1;
while (n != 0)
{
if (n > 0)
compressor.Write(buffer, 0, n);
n= input.Read(buffer, 0, buffer.Length);
}
}
}
// can write additional data to the output stream here
}
Using output As FileStream = File.Create(fileToCompress & ".deflated")
Using input As Stream = File.OpenRead(fileToCompress)
Using compressor As Stream = New DeflateStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, True)
Dim buffer As Byte() = New Byte(4096) {}
Dim n As Integer = -1
Do While (n <> 0)
If (n > 0) Then
compressor.Write(buffer, 0, n)
End If
n = input.Read(buffer, 0, buffer.Length)
Loop
End Using
End Using
' can write additional data to the output stream here.
End Using
using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
{
using (var raw = System.IO.File.Create(outputFile))
{
using (Stream compressor = new GZipStream(raw, CompressionMode.Compress))
{
byte[] buffer = new byte[WORKING_BUFFER_SIZE];
int n;
while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
{
compressor.Write(buffer, 0, n);
}
}
}
}
Dim outputFile As String = (fileToCompress & ".compressed")
Using input As Stream = File.OpenRead(fileToCompress)
Using raw As FileStream = File.Create(outputFile)
Using compressor As Stream = New GZipStream(raw, CompressionMode.Compress)
Dim buffer As Byte() = New Byte(4096) {}
Dim n As Integer = -1
Do While (n <> 0)
If (n > 0) Then
compressor.Write(buffer, 0, n)
End If
n = input.Read(buffer, 0, buffer.Length)
Loop
End Using
End Using
End Using
private void GunZipFile(string filename)
{
if (!filename.EndsWith(".gz))
throw new ArgumentException("filename");
var DecompressedFile = filename.Substring(0,filename.Length-3);
byte[] working = new byte[WORKING_BUFFER_SIZE];
int n= 1;
using (System.IO.Stream input = System.IO.File.OpenRead(filename))
{
using (Stream decompressor= new Ionic.Zlib.GZipStream(input, CompressionMode.Decompress, true))
{
using (var output = System.IO.File.Create(DecompressedFile))
{
while (n !=0)
{
n= decompressor.Read(working, 0, working.Length);
if (n > 0)
{
output.Write(working, 0, n);
}
}
}
}
}
}
Private Sub GunZipFile(ByVal filename as String)
If Not (filename.EndsWith(".gz)) Then
Throw New ArgumentException("filename")
End If
Dim DecompressedFile as String = filename.Substring(0,filename.Length-3)
Dim working(WORKING_BUFFER_SIZE) as Byte
Dim n As Integer = 1
Using input As Stream = File.OpenRead(filename)
Using decompressor As Stream = new Ionic.Zlib.GZipStream(input, CompressionMode.Decompress, True)
Using output As Stream = File.Create(UncompressedFile)
Do
n= decompressor.Read(working, 0, working.Length)
If n > 0 Then
output.Write(working, 0, n)
End IF
Loop While (n > 0)
End Using
End Using
End Using
End Sub
using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
{
using (var raw = System.IO.File.Create(fileToCompress + ".gz"))
{
using (Stream compressor = new GZipStream(raw,
CompressionMode.Compress,
CompressionLevel.BestCompression))
{
byte[] buffer = new byte[WORKING_BUFFER_SIZE];
int n;
while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
{
compressor.Write(buffer, 0, n);
}
}
}
}
Using input As Stream = File.OpenRead(fileToCompress)
Using raw As FileStream = File.Create(fileToCompress & ".gz")
Using compressor As Stream = New GZipStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression)
Dim buffer As Byte() = New Byte(4096) {}
Dim n As Integer = -1
Do While (n <> 0)
If (n > 0) Then
compressor.Write(buffer, 0, n)
End If
n = input.Read(buffer, 0, buffer.Length)
Loop
End Using
End Using
End Using
using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
{
using (var raw = System.IO.File.Create(outputFile))
{
using (Stream compressor = new GZipStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression, true))
{
byte[] buffer = new byte[WORKING_BUFFER_SIZE];
int n;
while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
{
compressor.Write(buffer, 0, n);
}
}
}
}
Dim outputFile As String = (fileToCompress & ".compressed")
Using input As Stream = File.OpenRead(fileToCompress)
Using raw As FileStream = File.Create(outputFile)
Using compressor As Stream = New GZipStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression, True)
Dim buffer As Byte() = New Byte(4096) {}
Dim n As Integer = -1
Do While (n <> 0)
If (n > 0) Then
compressor.Write(buffer, 0, n)
End If
n = input.Read(buffer, 0, buffer.Length)
Loop
End Using
End Using
End Using
byte[] working = new byte[WORKING_BUFFER_SIZE];
using (System.IO.Stream input = System.IO.File.OpenRead(_CompressedFile))
{
using (Stream decompressor= new Ionic.Zlib.GZipStream(input, CompressionMode.Decompress, true))
{
using (var output = System.IO.File.Create(_DecompressedFile))
{
int n;
while ((n= decompressor.Read(working, 0, working.Length)) !=0)
{
output.Write(working, 0, n);
}
}
}
}
byte[] buffer = new byte[WORKING_BUFFER_SIZE];
int n= -1;
String outputFile = fileToCompress + ".compressed";
using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
{
using (var raw = System.IO.File.Create(outputFile))
{
using (Stream compressor = new ParallelDeflateOutputStream(raw))
{
while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
{
compressor.Write(buffer, 0, n);
}
}
}
}
Dim buffer As Byte() = New Byte(4096) {}
Dim n As Integer = -1
Dim outputFile As String = (fileToCompress & ".compressed")
Using input As Stream = File.OpenRead(fileToCompress)
Using raw As FileStream = File.Create(outputFile)
Using compressor As Stream = New ParallelDeflateOutputStream(raw)
Do While (n <> 0)
If (n > 0) Then
compressor.Write(buffer, 0, n)
End If
n = input.Read(buffer, 0, buffer.Length)
Loop
End Using
End Using
End Using
ParallelDeflateOutputStream deflater = null;
foreach (var inputFile in listOfFiles)
{
string outputFile = inputFile + ".compressed";
using (System.IO.Stream input = System.IO.File.OpenRead(inputFile))
{
using (var outStream = System.IO.File.Create(outputFile))
{
if (deflater == null)
deflater = new ParallelDeflateOutputStream(outStream,
CompressionLevel.Best,
CompressionStrategy.Default,
true);
deflater.Reset(outStream);
while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
{
deflater.Write(buffer, 0, n);
}
}
}
}
var adler = Adler.Adler32(0, null, 0, 0);
adler = Adler.Adler32(adler, buffer, index, length);
private void InflateBuffer()
{
int bufferSize = 1024;
byte[] buffer = new byte[bufferSize];
ZlibCodec decompressor = new ZlibCodec();
Console.WriteLine("\n============================================");
Console.WriteLine("Size of Buffer to Inflate: {0} bytes.", CompressedBytes.Length);
MemoryStream ms = new MemoryStream(DecompressedBytes);
int rc = decompressor.InitializeInflate();
decompressor.InputBuffer = CompressedBytes;
decompressor.NextIn = 0;
decompressor.AvailableBytesIn = CompressedBytes.Length;
decompressor.OutputBuffer = buffer;
// pass 1: inflate
do
{
decompressor.NextOut = 0;
decompressor.AvailableBytesOut = buffer.Length;
rc = decompressor.Inflate(FlushType.None);
if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
throw new Exception("inflating: " + decompressor.Message);
ms.Write(decompressor.OutputBuffer, 0, buffer.Length - decompressor.AvailableBytesOut);
}
while (decompressor.AvailableBytesIn > 0 || decompressor.AvailableBytesOut == 0);
// pass 2: finish and flush
do
{
decompressor.NextOut = 0;
decompressor.AvailableBytesOut = buffer.Length;
rc = decompressor.Inflate(FlushType.Finish);
if (rc != ZlibConstants.Z_STREAM_END && rc != ZlibConstants.Z_OK)
throw new Exception("inflating: " + decompressor.Message);
if (buffer.Length - decompressor.AvailableBytesOut > 0)
ms.Write(buffer, 0, buffer.Length - decompressor.AvailableBytesOut);
}
while (decompressor.AvailableBytesIn > 0 || decompressor.AvailableBytesOut == 0);
decompressor.EndInflate();
}
int bufferSize = 40000;
byte[] CompressedBytes = new byte[bufferSize];
byte[] DecompressedBytes = new byte[bufferSize];
ZlibCodec compressor = new ZlibCodec();
compressor.InitializeDeflate(CompressionLevel.Default);
compressor.InputBuffer = System.Text.ASCIIEncoding.ASCII.GetBytes(TextToCompress);
compressor.NextIn = 0;
compressor.AvailableBytesIn = compressor.InputBuffer.Length;
compressor.OutputBuffer = CompressedBytes;
compressor.NextOut = 0;
compressor.AvailableBytesOut = CompressedBytes.Length;
while (compressor.TotalBytesIn != TextToCompress.Length && compressor.TotalBytesOut < bufferSize)
{
compressor.Deflate(FlushType.None);
}
while (true)
{
int rc= compressor.Deflate(FlushType.Finish);
if (rc == ZlibConstants.Z_STREAM_END) break;
}
compressor.EndDeflate();
private void DeflateBuffer(CompressionLevel level)
{
int bufferSize = 1024;
byte[] buffer = new byte[bufferSize];
ZlibCodec compressor = new ZlibCodec();
Console.WriteLine("\n============================================");
Console.WriteLine("Size of Buffer to Deflate: {0} bytes.", UncompressedBytes.Length);
MemoryStream ms = new MemoryStream();
int rc = compressor.InitializeDeflate(level);
compressor.InputBuffer = UncompressedBytes;
compressor.NextIn = 0;
compressor.AvailableBytesIn = UncompressedBytes.Length;
compressor.OutputBuffer = buffer;
// pass 1: deflate
do
{
compressor.NextOut = 0;
compressor.AvailableBytesOut = buffer.Length;
rc = compressor.Deflate(FlushType.None);
if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
throw new Exception("deflating: " + compressor.Message);
ms.Write(compressor.OutputBuffer, 0, buffer.Length - compressor.AvailableBytesOut);
}
while (compressor.AvailableBytesIn > 0 || compressor.AvailableBytesOut == 0);
// pass 2: finish and flush
do
{
compressor.NextOut = 0;
compressor.AvailableBytesOut = buffer.Length;
rc = compressor.Deflate(FlushType.Finish);
if (rc != ZlibConstants.Z_STREAM_END && rc != ZlibConstants.Z_OK)
throw new Exception("deflating: " + compressor.Message);
if (buffer.Length - compressor.AvailableBytesOut > 0)
ms.Write(buffer, 0, buffer.Length - compressor.AvailableBytesOut);
}
while (compressor.AvailableBytesIn > 0 || compressor.AvailableBytesOut == 0);
compressor.EndDeflate();
ms.Seek(0, SeekOrigin.Begin);
CompressedBytes = new byte[compressor.TotalBytesOut];
ms.Read(CompressedBytes, 0, CompressedBytes.Length);
}
using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
{
using (var raw = System.IO.File.Create(fileToCompress + ".zlib"))
{
using (Stream compressor = new ZlibStream(raw, CompressionMode.Compress))
{
byte[] buffer = new byte[WORKING_BUFFER_SIZE];
int n;
while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
{
compressor.Write(buffer, 0, n);
}
}
}
}
Using input As Stream = File.OpenRead(fileToCompress)
Using raw As FileStream = File.Create(fileToCompress & ".zlib")
Using compressor As Stream = New ZlibStream(raw, CompressionMode.Compress)
Dim buffer As Byte() = New Byte(4096) {}
Dim n As Integer = -1
Do While (n <> 0)
If (n > 0) Then
compressor.Write(buffer, 0, n)
End If
n = input.Read(buffer, 0, buffer.Length)
Loop
End Using
End Using
End Using
using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
{
using (var raw = System.IO.File.Create(fileToCompress + ".zlib"))
{
using (Stream compressor = new ZlibStream(raw,
CompressionMode.Compress,
CompressionLevel.BestCompression))
{
byte[] buffer = new byte[WORKING_BUFFER_SIZE];
int n;
while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
{
compressor.Write(buffer, 0, n);
}
}
}
}
Using input As Stream = File.OpenRead(fileToCompress)
Using raw As FileStream = File.Create(fileToCompress & ".zlib")
Using compressor As Stream = New ZlibStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression)
Dim buffer As Byte() = New Byte(4096) {}
Dim n As Integer = -1
Do While (n <> 0)
If (n > 0) Then
compressor.Write(buffer, 0, n)
End If
n = input.Read(buffer, 0, buffer.Length)
Loop
End Using
End Using
End Using
using (var output = System.IO.File.Create(fileToCompress + ".zlib"))
{
using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
{
using (Stream compressor = new ZlibStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, true))
{
byte[] buffer = new byte[WORKING_BUFFER_SIZE];
int n;
while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
{
compressor.Write(buffer, 0, n);
}
}
}
// can write additional data to the output stream here
}
Using output As FileStream = File.Create(fileToCompress & ".zlib")
Using input As Stream = File.OpenRead(fileToCompress)
Using compressor As Stream = New ZlibStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, True)
Dim buffer As Byte() = New Byte(4096) {}
Dim n As Integer = -1
Do While (n <> 0)
If (n > 0) Then
compressor.Write(buffer, 0, n)
End If
n = input.Read(buffer, 0, buffer.Length)
Loop
End Using
End Using
' can write additional data to the output stream here.
End Using