Commit b26c6573 authored by Meelad Vahdat's avatar Meelad Vahdat

-Initial commit into new repository

Changes from previous version:

*BusinessCoder (following changes made by Michael B.)
- Options made more clear
- maxRecsPerRequest increased from 5 to 100 (the service has been improved)
- Fields now prefixed with MD_ instead of BC_
- RecordID removed from input and output
- Result codes now removed regardless
- Input columns renamed so that they utilize the auto detect feature

*All components (changes made by Meelad V.)
- Sequential rerun logic fixed so that incorrect status messages are not shown
- Plus4 mapping dropped in Services
- RecordID mapping dropped in input and output of all services
- Results output removed from all services as it is now returned regardless of    selection
- Output file is filled by default when input file is fielded
- Credits consumed are shown when a run is finished
- Source is set for LWDT to be used by every service
- Reporting module created by Tim S., Aria U., and Katie B., and integrated by Meelad V.
- Input and output file textboxes will not validate if user enters texts and presses enter or leaves textbox (instead of solely being able to validate via the select input/output button)
- Comments added throughout code to help reader
Signed-off-by: Meelad Vahdat's avatarMeelad Vahdat <meelad@melissadata.com>
parents

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2013
VisualStudioVersion = 12.0.40629.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ListwareDesktop", "ListwareDesktop\ListwareDesktop.csproj", "{51458CD7-9832-48B0-B9FA-C5983F5662F4}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{51458CD7-9832-48B0-B9FA-C5983F5662F4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{51458CD7-9832-48B0-B9FA-C5983F5662F4}.Debug|Any CPU.Build.0 = Debug|Any CPU
{51458CD7-9832-48B0-B9FA-C5983F5662F4}.Release|Any CPU.ActiveCfg = Release|Any CPU
{51458CD7-9832-48B0-B9FA-C5983F5662F4}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<configSections>
<sectionGroup name="userSettings" type="System.Configuration.UserSettingsGroup, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >
<section name="MelissaBatchAppV2.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" requirePermission="false" />
</sectionGroup>
</configSections>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
</startup>
<userSettings>
<MelissaBatchAppV2.Properties.Settings>
<setting name="customerID" serializeAs="String">
<value />
</setting>
</MelissaBatchAppV2.Properties.Settings>
</userSettings>
</configuration>
\ No newline at end of file
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ListwareDesktop.Framework
{
//This is a static class to help auto detect inputs. Add any more variations here.
internal static class AutoDetectInputs
{
static string[] firstNameVariations = { "namefirst", "first", "firstname", "fname", "first name", "f name", "first_name", "fn", "firstnm" };
static string[] lastNameVariations = { "namelast", "last", "lastname", "lname", "last name", "l name", "last_name", "ln", "lastnm" };
static string[] fullNameVariations = { "namefull", "fullname", "name", "full name", "contact", "name1", "name 1" };
static string[] addressVariations = { "a1", "addressline1", "address", "street", "addressline1", "address line1", "address 1", "address1", "street address", "address_1", "delivery address", "str1", "add1", "addr1", "business address", "add 1", "address line 1" };
static string[] address2Variations = { "a2", "addressline2", "address2", "addressline2", "address line2", "street2", "street 2", "address 2", "address_2", "str2", "add2", "add 2", "addr2", "address line 2" };
static string[] cityVariations = { "city", "town" };
static string[] stateVariations = { "state", "st", "province", "prov" };
static string[] zipVariations = { "postal", "zip", "zipcode", "postalcode", "postal_code", "postal code", "post_code", "postcode", "post code" };
static string[] companyVariations = { "company", "business", "organization", "organization name" };
static string[] suiteVariations = { "suite" };
static string[] plus4Variations = { "+4", "plus4", "plus 4" };
static string[] recordIDVariations = { "recordid", "recnum", "recno", "recid", "id", "rec" };
//This relates input column names to the variation lists
//Add input columns from services here in all lower case as the key, then the variation list as the value
internal static Dictionary<string, string[]> variationDictionary = new Dictionary<string, string[]>()
{
{"namefirst", firstNameVariations},
{"namelast", lastNameVariations},
{"namefull", fullNameVariations},
{"addressline1", addressVariations},
{"addressline2", address2Variations},
{"city", cityVariations},
{"state", stateVariations},
{"postalcode", zipVariations},
{"company", companyVariations},
{"suite", suiteVariations},
{"plus4", plus4Variations},
{"firstname", firstNameVariations},
{"lastname", lastNameVariations},
{"fullname", fullNameVariations},
{"companyname", companyVariations},
{"recordid", recordIDVariations}
};
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ListwareDesktop.Framework
{
public interface IWS
{
/*
* Those who are creating a web service class must do so in the following way
* All of the following methods must be implemented, with the class for the service extending this interface
*
* settingsList - A dictionary of all top level elements and values. Declare and set this in the constructor. For example,
* Smartmover would use columns, JobID, NumberOfMonthsRequested,ProcessingType,ListOwnerFreqProcessing
* There are three types of options integrated into settingsList: Manual, Single, and Multiple
* Manual is a manual entry option. For example, NumberOfMonthsRequested requires the user to put in a value between 6 and 48.
* Therefore, the entry for this option would look like the following:
* Key: NumberOfMonthsRequested
* Value: Manual,6-48
* With manual entry options, the second value of the key is what the display box will show to the user. This value will not be taken into the WS
* Single is for options where users can only select a single option. For example, ProcessingType requires a user to pick either Residence, Business, Individual, etc.
* Therefore, the entry for the option would look like the following:
* Key: ProcessingType
* Value: Single, Standard, Individual, IndividualAndBusiness, Business, Residential
* Multiple is for options where users can select multiple options simultaneously. For example, Columns, the user can pick grpStandardized,grpOriginal, or even individual columns like so:
* Key: Columns
* Value: Multiple, DPVFootNotes, MoveReturnCode, Plus4, PrivateMailBox, Suite, GrpParsed, GrpName, GrpOriginal, GrpStandardized
*
* serviceOptions - This is a dictionary of all of the options, as well as the values corresponding to the options that the user has chosen. This will be passed back
* into the class after the user has selected all of their options. There is a possibility where this can be blank if a user has not selected anything at all.
* Declare this in the constructor but DO NOT set any values.
*
* inputColumns - A list of all of the input columns for the service. Declare and set this in the constructor.
*
* outputColumns - A list of all of the possible output columns for the service. Declare and set this in the constructor.
*
* maxRecsPerRequest - This controls how many records will be passed to the service at a time by the GUI. Declare and set this in the constructor.
*
* sendToService - This is the method that the GUI passes the records into. This is the "black box". This method is where you will do your processing however you wish.
*
* outputRecords - This is where you will place the output records when you are finished processing.
*
* errorStatus - A boolean that will be false by default. Set to true when there is an error and the GUI will stop processing.
*
* statusMessage - A statusMessage that will be passed to the GUI. When there is an issue, set this to some message for the user and set errorStatus to true. If there is no error
* but you want to send a message to the user regardless (like a warning or processing %), set this with errorStatus set to false.
*
* userLicense - The user's license will be set here by the GUI for the class.
*
* needsAllRecords - Set this to true if the class needs all records before processing (such as the MatchUp Webservice)
*
* serviceFinishedProcessing - If needsAllRecords is set to true, set this bool to true when you are done processing. Otherwise, you can leave it alone.
*
* inputRecordsFinished - If needs all records is set to true, then the GUI will set this bool to true when it has finished passing in all of the records.
*/
//Dictionary of all options and the values the user has set for them
Dictionary<string, string> serviceOptions { get; set; }
//Dictionary of all options and their possible values
Dictionary<string, List<string>> settingsList { get; set; }
//All possible input columns DECLARE AND SET IN CONSTRUCTOR
string[] inputColumns { get; set; }
//All possible output columns DECLARE AND SET IN CONSTRUCTOR
string[] outputColumns { get; set; }
//Maximum records per request, typically 100 or 1 DECLARE AND SET IN CONSTRUCTOR
int maxRecsPerRequest { get; set; }
//Send input records to service and set the output records
void sendToService(Record[] inputRecords);
//Set this to the outputRecords that are to be returned to the GUI
Record[] outputRecords { get; set; }
//This is set to true if there is an error
bool errorStatus { get; set; }
//Any possible status messages to pass to the GUI, including error status messages
string statusMessage { get; set; }
//This is set so the service can access the license more easily
string userLicense { get; set; }
//This is to differentiate the types of services
//For services such as Personator, SmartMover that can receive x request records then return y response records select false
//For services such as MUWS where you need all records before returning select true
bool needsAllRecords { get; set; }
//This boolean is set by the WS class
//Lets the GUI know when the class is ready to output records
bool serviceFinishedProcessing { get; set; }
//This boolean is set by the GUI
//Lets the WS class know when the GUI is finished sending in records
bool inputRecordsFinished { get; set; }
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.IO;
using Microsoft.VisualBasic.FileIO;
namespace ListwareDesktop.Framework
{
public class Input
{
private StreamReader streamReader;
internal string[] headerFieldNames { get; set; }
private string filePath { get; set; }
private string delimiter;
private string qualifier;
//Constructor, set all options for the stream reader
internal Input(string filePath, string delimiter, string qualifier)
{
this.filePath = filePath;
this.delimiter = delimiter;
this.qualifier = qualifier;
this.streamReader = new StreamReader(filePath);
this.headerFieldNames = getFields(streamReader.ReadLine());
}
//Get the fields from a full line, use a regex to split if there's a specific type of qualifier
private string[] getFields(string inputText)
{
List<string> tokens = new List<string>();
if (qualifier == null)
{
return inputText.Split(delimiter[0]).Select(s => s.Trim()).ToArray();
}
else
{
string pattern = string.Format(@"{0}(?=(?:[^{1}]*{1}[^{1}]*{1})*(?![^{1}]*{1}))",Regex.Escape(delimiter),Regex.Escape(qualifier));
string[] split = Regex.Split(inputText, pattern);
return split.Select(s => s.Trim(qualifier[0],' ')).ToArray();
}
}
//Use this method for the file preview pane
internal Record[] getRecordsForPreview()
{
List<Record> recordList = new List<Record>();
for (int i = 0; i < 100; i++)
{
if (!streamReader.EndOfStream)
{
recordList.Add(new Record(headerFieldNames, getFields(streamReader.ReadLine())));
}
}
return recordList.ToArray();
}
//Get lines using the reader, split them with getFields()
internal Record[] getRecords(int amountOfRecords)
{
List<Record> returnRecordList = new List<Record>();
for (int i = 0; i < amountOfRecords; i++)
{
if (!streamReader.EndOfStream)
{
string[] fields = getFields(streamReader.ReadLine());
returnRecordList.Add(new Record(headerFieldNames, fields));
}
}
return returnRecordList.ToArray();
}
//To make sure we end when we're supposed to
internal bool checkForEnd()
{
return streamReader.EndOfStream;
}
//To dispose of the reader
internal void closeReader()
{
streamReader.Close();
streamReader.Dispose();
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
namespace ListwareDesktop.Framework
{
public class Output
{
private StreamWriter streamWriter;
private string[] headerFieldNames;
private string filePath { get; set; }
private string delimiter;
private string qualifier;
//Constructor that sets all the settings for the writer
internal Output(string filePath, string delimiter, string qualifier)
{
this.filePath = filePath;
this.delimiter = delimiter;
this.qualifier = qualifier;
this.streamWriter = new StreamWriter(filePath);
streamWriter.AutoFlush = true;
}
//Writes records with qualifier + delimiter
internal void sendRecords(Record[] recordsToBeWritten)
{
this.checkIfEmpty(recordsToBeWritten[0]);
foreach (Record tempRecord in recordsToBeWritten)
{
string tempString = "";
foreach (string currentHeader in headerFieldNames)
{
if ((qualifier == null) && (tempRecord.fieldAndData[currentHeader].Contains(delimiter)))
{
tempString += "\"" + tempRecord.fieldAndData[currentHeader] + "\"" + delimiter;
}
else
{
tempString += qualifier + tempRecord.fieldAndData[currentHeader] + qualifier + delimiter;
}
}
streamWriter.WriteLine(tempString);
}
}
//Writes header line
internal void writeHeaders(Record sampleRecord)
{
headerFieldNames = sampleRecord.fieldAndData.Keys.ToArray();
string tempString = "";
foreach (string header in headerFieldNames)
{
tempString += qualifier + header + qualifier + delimiter;
}
streamWriter.WriteLine(tempString);
}
internal void checkIfEmpty(Record sampleRecord)
{
if (new FileInfo(filePath).Length == 0)
{
this.writeHeaders(sampleRecord);
}
}
//Close writer
internal void closeWriter()
{
streamWriter.Close();
streamWriter.Dispose();
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ListwareDesktop.Framework
{
//Basic record class.
//Each class will be made for a record, and it will hold the
//header column name as well as the column data for 1 record.
public class Record
{
internal Dictionary<string, string> fieldAndData { get; set; }
internal int recordID { get; set; }
internal Record(Dictionary<string, string> inputDictionary)
{
this.fieldAndData = new Dictionary<string, string>(inputDictionary);
}
//Constructor
internal Record(string[] fieldNames, string[] data)
{
//Allocate new dictionary
this.fieldAndData = new Dictionary<string, string>();
//Zip up list of corresponding header names and data into a single dictionary for the record
fieldAndData = fieldNames.Zip(data, (f, d) => new { f, d }).ToDictionary(x => x.f, x => x.d);
}
//Constructor to create a new record from the input record
//There were some issues with records being passed by reference rather than value
internal Record(Record inputRecord)
{
this.fieldAndData = new Dictionary<string, string>(inputRecord.fieldAndData);
this.recordID = inputRecord.recordID;
}
//This is to add a singular field to the record
internal void addField(string fieldName, string fieldValue)
{
if (!fieldAndData.ContainsKey(fieldName))
{
fieldAndData.Add(fieldName, fieldValue);
}
else
{
fieldAndData[fieldName] = fieldValue;
}
}
//This method is used to combine pass through fields with output fields.
//Ensure that they have different field names
internal void combineRecord(Record tempRecord)
{
foreach (KeyValuePair<string, string> innerKVP in tempRecord.fieldAndData)
{
this.addField(innerKVP.Key.ToString(), innerKVP.Value.ToString());
}
}
//Initializing a new record
internal Record()
{
this.fieldAndData = new Dictionary<string, string>();
}
}
}
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProjectGuid>{51458CD7-9832-48B0-B9FA-C5983F5662F4}</ProjectGuid>
<OutputType>WinExe</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>ListwareDesktop</RootNamespace>
<AssemblyName>ListwareDesktop</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<PlatformTarget>AnyCPU</PlatformTarget>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<Prefer32Bit>false</Prefer32Bit>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<PlatformTarget>AnyCPU</PlatformTarget>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="Microsoft.VisualBasic" />
<Reference Include="Newtonsoft.Json, Version=10.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
<HintPath>..\packages\Newtonsoft.Json.10.0.3\lib\net45\Newtonsoft.Json.dll</HintPath>
<Private>True</Private>
</Reference>
<Reference Include="System" />
<Reference Include="System.Core" />
<Reference Include="System.Net" />
<Reference Include="System.Web" />
<Reference Include="System.Web.Extensions" />
<Reference Include="System.Windows.Forms.DataVisualization" />
<Reference Include="System.Xml.Linq" />
<Reference Include="System.Data.DataSetExtensions" />
<Reference Include="Microsoft.CSharp" />
<Reference Include="System.Data" />
<Reference Include="System.Deployment" />
<Reference Include="System.Drawing" />
<Reference Include="System.Windows.Forms" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="Framework\AutoDetectInputs.cs" />
<Compile Include="Framework\Input.cs" />
<Compile Include="Framework\IWS.cs" />
<Compile Include="Framework\Output.cs" />
<Compile Include="Framework\Record.cs" />
<Compile Include="MainForm.cs">
<SubType>Form</SubType>
</Compile>
<Compile Include="MainForm.Designer.cs">
<DependentUpon>MainForm.cs</DependentUpon>
</Compile>
<Compile Include="Program.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Reporting\GenerateReport.cs" />
<Compile Include="Services\BusinessCoder.cs" />
<Compile Include="Services\GlobalAddress.cs" />
<Compile Include="Services\GlobalEmail.cs" />
<Compile Include="Services\GlobalIP.cs" />
<Compile Include="Services\GlobalName.cs" />
<Compile Include="Services\GlobalPhone.cs" />
<Compile Include="Services\Personator.cs" />
<Compile Include="Windows\InputPreviewForm.cs">
<SubType>Form</SubType>
</Compile>
<Compile Include="Windows\InputPreviewForm.Designer.cs">
<DependentUpon>InputPreviewForm.cs</DependentUpon>
</Compile>
<Compile Include="Windows\SetConfigurationForm.cs">
<SubType>Form</SubType>
</Compile>
<Compile Include="Windows\SetConfigurationForm.Designer.cs">
<DependentUpon>SetConfigurationForm.cs</DependentUpon>
</Compile>
<Compile Include="Windows\SetInputsForm.cs">
<SubType>Form</SubType>
</Compile>
<Compile Include="Windows\SetInputsForm.Designer.cs">
<DependentUpon>SetInputsForm.cs</DependentUpon>
</Compile>
<Compile Include="Windows\SetOutputsForm.cs">
<SubType>Form</SubType>
</Compile>
<Compile Include="Windows\SetOutputsForm.Designer.cs">
<DependentUpon>SetOutputsForm.cs</DependentUpon>
</Compile>
<EmbeddedResource Include="MainForm.resx">
<DependentUpon>MainForm.cs</DependentUpon>
</EmbeddedResource>
<EmbeddedResource Include="Properties\Resources.resx">
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>Resources.Designer.cs</LastGenOutput>
<SubType>Designer</SubType>
</EmbeddedResource>
<Compile Include="Properties\Resources.Designer.cs">
<AutoGen>True</AutoGen>
<DependentUpon>Resources.resx</DependentUpon>
<DesignTime>True</DesignTime>
</Compile>
<EmbeddedResource Include="Windows\InputPreviewForm.resx">
<DependentUpon>InputPreviewForm.cs</DependentUpon>
</EmbeddedResource>
<EmbeddedResource Include="Windows\SetConfigurationForm.resx">
<DependentUpon>SetConfigurationForm.cs</DependentUpon>
</EmbeddedResource>
<EmbeddedResource Include="Windows\SetInputsForm.resx">
<DependentUpon>SetInputsForm.cs</DependentUpon>
</EmbeddedResource>
<EmbeddedResource Include="Windows\SetOutputsForm.resx">
<DependentUpon>SetOutputsForm.cs</DependentUpon>
</EmbeddedResource>
<None Include="packages.config" />
<None Include="Properties\Settings.settings">
<Generator>SettingsSingleFileGenerator</Generator>
<LastGenOutput>Settings.Designer.cs</LastGenOutput>
</None>
<Compile Include="Properties\Settings.Designer.cs">
<AutoGen>True</AutoGen>
<DependentUpon>Settings.settings</DependentUpon>
<DesignTimeSharedInput>True</DesignTimeSharedInput>
</Compile>
<None Include="Reporting\ValidDescriptions.cfg" />
<None Include="Reporting\ValidFilters.cfg" />
</ItemGroup>
<ItemGroup>
<None Include="App.config" />
</ItemGroup>
<ItemGroup>
<Content Include="Reporting\ReportTemplate.html" />
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>
\ No newline at end of file
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<PublishUrlHistory>publish\</PublishUrlHistory>
<InstallUrlHistory />
<SupportUrlHistory>https://www.melissa.com/company/support</SupportUrlHistory>
<UpdateUrlHistory />
<BootstrapperUrlHistory />
<ErrorReportUrlHistory>http://wiki.melissadata.com/</ErrorReportUrlHistory>
<FallbackCulture>en-US</FallbackCulture>
<VerifyUploadedFiles>false</VerifyUploadedFiles>
</PropertyGroup>
</Project>
\ No newline at end of file
This diff is collapsed.
This diff is collapsed.
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>