internal static StringBuilder UnMask(this StringBuilder builder, VCdVersion version)
{
Debug.Assert(builder != null);
if (version == VCdVersion.V2_1)
{
_ = builder.Replace(@"\;", ";");
return(builder);
}
if (version >= VCdVersion.V4_0)
{
_ = builder
.Replace(@"\\", @"\");
}
_ = builder
.Replace(@"\n", Environment.NewLine)
.Replace(@"\N", Environment.NewLine)
.Replace(@"\,", ",")
.Replace(@"\;", ";")
//.Replace(@"\:", ":")
;
return(builder);
}
public static void SerializeVcf(
this IEnumerable <VCard?> vCards,
Stream stream,
VCdVersion version = VCard.DEFAULT_VERSION,
VcfOptions options = VcfOptions.Default,
bool leaveStreamOpen = false)
=> VCard.SerializeVcf(stream, vCards, version, options: options, leaveStreamOpen: leaveStreamOpen);
public void AppendToTest2(VCdVersion version)
{
var sb = new StringBuilder();
GeoCoordinateConverter.AppendTo(sb, null, version);
Assert.AreEqual(0, sb.Length);
}
internal VcfReader(TextReader reader, VcfDeserializationInfo info, VCdVersion versionHint = VCdVersion.V2_1)
{
this._reader = reader;
this._info = info;
this.EOF = false;
this._versionHint = versionHint;
}
internal static DateTimeProperty Create(VcfRow vcfRow, VCdVersion version)
{
Debug.Assert(vcfRow != null);
switch (vcfRow.Parameters.DataType)
{
case VCdDataType.DateAndOrTime:
case VCdDataType.DateTime:
case VCdDataType.Date:
case VCdDataType.TimeStamp:
case null:
{
return(vcfRow.Info.DateAndOrTimeConverter.TryParse(vcfRow.Value, out DateTimeOffset dateTimeOffset)
? new DateTimeOffsetProperty(dateTimeOffset, vcfRow)
: new DateTimeTextProperty(vcfRow, version));
}
case VCdDataType.Time:
{
return(vcfRow.Info.TimeConverter.TryParse(vcfRow.Value, out DateTimeOffset dateTimeOffset)
? new DateTimeOffsetProperty(dateTimeOffset, vcfRow)
: new DateTimeTextProperty(vcfRow, version));
}
default:
{
return(new DateTimeTextProperty(vcfRow, version));
}
}//switch
}
internal static StringBuilder Mask(this StringBuilder builder, VCdVersion version)
{
Debug.Assert(builder != null);
if (version == VCdVersion.V2_1)
{
_ = builder.Replace(";", @"\;");
return(builder);
}
if (version >= VCdVersion.V4_0)
{
_ = builder
.Replace(@"\", @"\\");
}
_ = builder
.Replace(Environment.NewLine, NEWLINE_REPLACEMENT)
.Replace(",", @"\,")
.Replace(";", @"\;");
//if (version == VCdVersion.V3_0 && options.IsSet(VcfOptions.MaskColonInVcard_3_0))
//{
// builder.Replace(":", @"\:");
//}
return(builder);
}
internal static void AppendTo(StringBuilder builder, GeoCoordinate?coordinate, VCdVersion version)
{
Debug.Assert(builder != null);
if (coordinate is null)
{
return;
}
CultureInfo culture = CultureInfo.InvariantCulture;
string latitude = coordinate.Latitude.ToString("F6", culture);
string longitude = coordinate.Longitude.ToString("F6", culture);
switch (version)
{
case VCdVersion.V2_1:
case VCdVersion.V3_0:
_ = builder.Append(latitude).Append(';').Append(longitude);
break;
default:
_ = builder.Append("geo:").Append(latitude).Append(',').Append(longitude);
break;
}//switch
}
public void AppendToTest1(VCdVersion version, string expected)
{
var sb = new StringBuilder();
GeoCoordinateConverter.AppendTo(sb, new GeoCoordinate(0.8, 0.7), version);
Assert.AreEqual(expected, sb.ToString());
}
public void SerializeVcf(Stream stream,
VCdVersion version = DEFAULT_VERSION,
ITimeZoneIDConverter?tzConverter = null,
VcfOptions options = VcfOptions.Default,
bool leaveStreamOpen = false)
=> VCard.SerializeVcf(stream, this, version, tzConverter, options, leaveStreamOpen);
public void SaveVcfTest_ListNull(VCdVersion version)
{
List <VCard?>?list = null;
string path = Path.Combine(TestContext !.TestRunResultsDirectory, "SaveVcfTest_Empty.vcf");
list !.SaveVcf(path, version);
}
internal static string ToTimeString(DateTimeOffset dt, VCdVersion version)
{
var builder = new StringBuilder();
AppendTo(builder, dt, version);
return(builder.ToString());
}
////////////////////////////////////////////
static string GetVersionString(VCdVersion version)
{
return(version switch
{
VCdVersion.V2_1 => "2.1",
VCdVersion.V3_0 => "3.0",
VCdVersion.V4_0 => "4.0",
_ => "2.1"
});
public void SaveVcfTest_fileNameNull(VCdVersion version)
{
var list = new List <VCard?>()
{
new VCard()
};
list.SaveVcf(null !, version);
}
public void SaveVcfTest_EmptyList(VCdVersion version)
{
var list = new List <VCard?>();
string path = Path.Combine(TestContext !.TestRunResultsDirectory, "SaveVcfTest_Empty.vcf");
list.SaveVcf(path, version);
Assert.IsFalse(File.Exists(path));
}
internal void UnMask(VCdVersion version)
{
if (!_unMasked)
{
this.Value = this.Value.UnMask(Info.Builder, version);
_unMasked = true; // Unmask nicht 2x
DecodeQuotedPrintable();
}
}
internal static StringBuilder AppendUuid(this StringBuilder builder, Guid guid, VCdVersion version = VCdVersion.V4_0)
{
Debug.Assert(builder != null);
if (version >= VCdVersion.V4_0)
{
_ = builder.Append(UUID_PROTOCOL);
}
_ = builder.Append(guid.ToString()); // FormatProvider ist reserviert
return(builder);
}
public void SaveVcfTest_InvalidFilename(VCdVersion version)
{
var list = new List <VCard?>()
{
new VCard()
};
string path = " ";
list.SaveVcf(path, version);
Assert.IsFalse(File.Exists(path));
}
internal static void AppendTo(StringBuilder builder, DateTimeOffset dt, VCdVersion version)
{
switch (version)
{
case VCdVersion.V2_1:
case VCdVersion.V3_0:
{
_ = builder.AppendFormat(CultureInfo.InvariantCulture, "{0:00}:{1:00}:{2:00}",
dt.Hour, dt.Minute, dt.Second);
TimeSpan utcOffset = dt.Offset;
if (utcOffset == TimeSpan.Zero)
{
_ = builder.Append('Z');
}
else
{
string sign = utcOffset < TimeSpan.Zero ? "" : "+";
_ = builder.AppendFormat(CultureInfo.InvariantCulture, "{0}{1:00}:{2:00}", sign, utcOffset.Hours, utcOffset.Minutes);
}
break;
}
default: // vCard 4.0
{
_ = builder.AppendFormat(CultureInfo.InvariantCulture, "{0:00}{1:00}{2:00}",
dt.Hour, dt.Minute, dt.Second);
TimeSpan utcOffset = dt.Offset;
if (utcOffset == TimeSpan.Zero)
{
_ = builder.Append('Z');
}
else
{
string sign = utcOffset < TimeSpan.Zero ? "" : "+";
_ = builder.AppendFormat(CultureInfo.InvariantCulture, "{0}{1:00}:{2:00}", sign, utcOffset.Hours, utcOffset.Minutes);
}
break;
}
}
}
/// <summary>
/// Serialisiert <paramref name="vCards"/> als einen <see cref="string"/>, der den Inhalt einer VCF-Datei darstellt.
/// </summary>
///
/// <param name="vCards">Die zu serialisierenden <see cref="VCard"/>-Objekte. Die Sammlung darf leer sein und <c>null</c>-Werte
/// enthalten.</param>
/// <param name="version">Die vCard-Version, die für die Serialisierung verwendet wird.</param>
/// <param name="tzConverter">Ein Objekt, das <see cref="ITimeZoneIDConverter"/> implementiert, um beim Schreiben von vCard 2.1 oder
/// vCard 3.0 Zeitzonennamen aus der "IANA time zone database" in UTC-Offsets umwandeln zu können, oder <c>null</c>, um
/// auf eine Umwandlung zu verzichten.</param>
/// <param name="options">Optionen für das Serialisieren. Die Flags können
/// kombiniert werden.</param>
///
/// <returns><paramref name="vCards"/>, serialisiert als <see cref="string"/>, der den Inhalt einer VCF-Datei darstellt.</returns>
///
/// <remarks>
/// <note type="caution">
/// Obwohl die Methode selbst threadsafe ist, sind es die an die Methode übergebenen
/// <see cref="VCard"/>-Objekte nicht. Sperren Sie den lesenden und schreibenden Zugriff auf diese
/// <see cref="VCard"/>-Objekte während der Ausführung dieser Methode!
/// </note>
/// <note type="tip">
/// Sie können der Methode auch ein einzelnes <see cref="VCard"/>-Objekt übergeben, da die <see cref="VCard"/>-Klasse
/// <see cref="IEnumerable{T}">IEnumerable<VCard></see> explizit implementiert.
/// </note>
///
/// <para>Die Methode serialisiert möglicherweise mehr
/// vCards, als sich ursprünglich Elemente in <paramref name="vCards"/> befanden. Dies geschieht, wenn eine
/// vCard 4.0 serialisiert wird und sich
/// in den Eigenschaften <see cref="VCard.Members"/> oder <see cref="VCard.Relations"/> eines <see cref="VCard"/>-Objekts
/// weitere <see cref="VCard"/>-Objekte in Form von <see cref="RelationVCardProperty"/>-Objekten befanden.
/// Diese <see cref="VCard"/>-Objekte werden von der Methode an <paramref name="vCards"/> angefügt.
/// </para>
///
/// <para>Ebenso verhält sich die Methode, wenn eine vCard 2.1 oder 3.0 mit der Option <see cref="VcfOptions.IncludeAgentAsSeparateVCard"/>
/// serialisiert wird und wenn sich in der Eigenschaft <see cref="VCard.Relations"/> eines <see cref="VCard"/>-Objekts ein
/// <see cref="RelationVCardProperty"/>-Objekt befindet, auf dessen <see cref="ParameterSection"/> in der Eigenschaft <see cref="ParameterSection.RelationType"/>
/// das Flag <see cref="RelationTypes.Agent"/> gesetzt ist.
/// </para>
///
/// <para>
/// Wenn eine vCard 4.0 serialisiert wird, ruft die Methode <see cref="VCard.Dereference(IEnumerable{VCard?})"/> auf bevor sie erfolgreich
/// zurückkehrt. Im Fall, dass die Methode eine Ausnahme wirft, ist dies nicht garantiert.
/// </para>
///
/// </remarks>
///
///
/// <seealso cref="ITimeZoneIDConverter"/>
///
/// <exception cref="ArgumentNullException"><paramref name="vCards"/> ist <c>null</c>.</exception>
/// <exception cref="ArgumentException"><paramref name="version"/> hat einen nichtdefinierten Wert.</exception>
/// <exception cref="OutOfMemoryException">Es ist nicht genug Speicher vorhanden.</exception>
public static string ToVcfString(
IEnumerable <VCard?> vCards,
VCdVersion version = VCard.DEFAULT_VERSION,
ITimeZoneIDConverter?tzConverter = null,
VcfOptions options = VcfOptions.Default)
{
if (vCards is null)
{
throw new ArgumentNullException(nameof(vCards));
}
using var stream = new MemoryStream();
VCard.SerializeVcf(stream, vCards, version, tzConverter, options, leaveStreamOpen: true);
stream.Position = 0;
using var reader = new StreamReader(stream, Encoding.UTF8);
return(reader.ReadToEnd());
}
internal static string?UnMask(this string?value, StringBuilder sb, VCdVersion version)
{
Debug.Assert(sb != null);
if (value is null)
{
return(null);
}
if (value.Length == 0)
{
return(string.Empty);
}
_ = sb.Clear().Append(value).UnMask(version);
if (sb.Length == value.Length)
{
if (version < VCdVersion.V4_0)
{
return(value);
}
else
{
for (int i = 0; i < sb.Length; i++)
{
if (sb[i] != value[i])
{
return(sb.ToString());
}
}
return(value);
}
}
else
{
return(sb.ToString());
}
}
/// <summary>
/// Speichert eine Sammlung von <see cref="VCard"/>-Objekten in eine gemeinsame VCF-Datei.
/// </summary>
///
/// <param name="vCards">Die zu speichernden <see cref="VCard"/>-Objekte. Die Sammlung darf leer sein und <c>null</c>-Werte
/// enthalten. Wenn die Sammlung kein <see cref="VCard"/>-Objekt enthält, wird keine Datei geschrieben.</param>
/// <param name="fileName">Der Dateipfad. Wenn die Datei existiert, wird sie überschrieben.</param>
/// <param name="version">Die vCard-Version der zu speichernden VCF-Datei.</param>
/// <param name="options">Optionen für das Schreiben der VCF-Datei. Die Flags können
/// kombiniert werden.</param>
/// <param name="tzConverter">Ein Objekt, das <see cref="ITimeZoneIDConverter"/> implementiert, um beim Schreiben von vCard 2.1 oder
/// vCard 3.0 Zeitzonennamen aus der "IANA time zone database" in UTC-Offsets umwandeln zu können, oder <c>null</c>, um
/// auf eine Umwandlung zu verzichten.</param>
///
/// <remarks>
/// <note type="caution">
/// Obwohl die Methode selbst threadsafe ist, sind es die an die Methode übergebenen
/// <see cref="VCard"/>-Objekte nicht. Sperren Sie den lesenden und schreibenden Zugriff auf diese
/// <see cref="VCard"/>-Objekte während der Ausführung dieser Methode!
/// </note>
/// <note type="tip">
/// Sie können der Methode auch ein einzelnes <see cref="VCard"/>-Objekt übergeben, da die <see cref="VCard"/>-Klasse
/// <see cref="IEnumerable{T}">IEnumerable<VCard></see> explizit implementiert.
/// </note>
///
/// <para>Die Methode serialisiert möglicherweise mehr
/// vCards, als die Anzahl der Elemente in der Sammlung, die an den Parameter <paramref name="vCards"/> übergeben wird.
/// Dies geschieht, wenn eine VCF-Datei als
/// vCard 4.0 gespeichert wird und sich
/// in den Eigenschaften <see cref="VCard.Members"/> oder <see cref="VCard.Relations"/> eines <see cref="VCard"/>-Objekts
/// weitere <see cref="VCard"/>-Objekte in Form von <see cref="RelationVCardProperty"/>-Objekten befinden.
/// Diese <see cref="VCard"/>-Objekte werden von der Methode an <paramref name="vCards"/> angefügt.
/// </para>
///
/// <para>
/// Ebenso verhält sich die Methode, wenn eine vCard 2.1 oder 3.0 mit der Option <see cref="VcfOptions.IncludeAgentAsSeparateVCard"/>
/// serialisiert wird und wenn sich in der Eigenschaft <see cref="VCard.Relations"/> eines <see cref="VCard"/>-Objekts ein
/// <see cref="RelationVCardProperty"/>-Objekt befindet, auf dessen <see cref="ParameterSection"/> in der Eigenschaft <see cref="ParameterSection.RelationType"/>
/// das Flag <see cref="RelationTypes.Agent"/> gesetzt ist.
/// </para>
/// </remarks>
///
/// <seealso cref="ITimeZoneIDConverter"/>
///
/// <exception cref="ArgumentNullException"><paramref name="fileName"/> oder <paramref name="vCards"/>
/// ist <c>null</c>.</exception>
/// <exception cref="ArgumentException"><paramref name="fileName"/> ist kein gültiger Dateipfad oder <paramref name="version"/> hat einen nichtdefinierten Wert.</exception>
/// <exception cref="IOException">Die Datei konnte nicht geschrieben werden.</exception>
public static void SaveVcf(
string fileName,
IEnumerable <VCard?> vCards,
VCdVersion version = DEFAULT_VERSION,
ITimeZoneIDConverter?tzConverter = null,
VcfOptions options = VcfOptions.Default)
{
if (vCards is null)
{
throw new ArgumentNullException(nameof(vCards));
}
// verhindert, dass eine leere Datei geschrieben wird
if (!vCards.Any(x => x != null))
{
//File.Delete(fileName);
return;
}
using FileStream stream = InitializeFileStream(fileName);
SerializeVcf(stream, vCards, version, tzConverter, options, false);
}
internal void AppendTo(StringBuilder builder, VCdVersion version, ITimeZoneIDConverter?converter)
{
Debug.Assert(builder != null);
switch (version)
{
case VCdVersion.V2_1:
case VCdVersion.V3_0:
{
if (TryGetUtcOffset(out TimeSpan utcOffset, converter))
{
string format = utcOffset < TimeSpan.Zero ? @"\-hh\:mm" : @"\+hh\:mm";
_ = builder.Append(utcOffset.ToString(format, CultureInfo.InvariantCulture));
}
else
{
_ = builder.Append(Value);
}
break;
}
default:
{
if (IsUtcOffset() && TryGetUtcOffset(out TimeSpan utcOffset))
{
string format = utcOffset < TimeSpan.Zero ? @"\-hhmm" : @"\+hhmm";
_ = builder.Append(utcOffset.ToString(format, CultureInfo.InvariantCulture));
}
else
{
_ = builder.Append(Value);
}
break;
}
}
}
internal static void AppendTimeStampTo(StringBuilder builder,
DateTimeOffset?dto, VCdVersion version)
{
if (!dto.HasValue)
{
return;
}
DateTimeOffset dt = dto.Value.ToUniversalTime();
switch (version)
{
case VCdVersion.V2_1:
case VCdVersion.V3_0:
_ = builder.AppendFormat(CultureInfo.InvariantCulture, "{0:0000}-{1:00}-{2:00}T{3:00}:{4:00}:{5:00}Z",
dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second);
break;
default:
_ = builder.AppendFormat(CultureInfo.InvariantCulture, "{0:0000}{1:00}{2:00}T{3:00}{4:00}{5:00}Z",
dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second);
break;
}
}
public static void SaveVcf(
this IEnumerable <VCard?> vCards,
string fileName,
VCdVersion version = VCard.DEFAULT_VERSION,
VcfOptions options = VcfOptions.Default)
=> VCard.SaveVcf(fileName, vCards, version, options: options);
internal static void AppendDateTimeStringTo(StringBuilder builder,
DateTimeOffset?dto, VCdVersion version)
{
if (!dto.HasValue)
{
return;
}
DateTimeOffset dt = dto.Value;
switch (version)
{
case VCdVersion.V2_1:
case VCdVersion.V3_0:
{
_ = dt.Year >= FIRST_LEAP_YEAR
? builder.AppendFormat(CultureInfo.InvariantCulture, "{0:0000}-{1:00}-{2:00}", dt.Year, dt.Month, dt.Day)
: builder.AppendFormat(CultureInfo.InvariantCulture, "--{0:00}-{1:00}", dt.Month, dt.Day);
TimeSpan utcOffset = dt.Offset;
if (HasTimeComponent(dt))
{
_ = builder.AppendFormat(CultureInfo.InvariantCulture, "T{0:00}:{1:00}:{2:00}", dt.Hour, dt.Minute, dt.Second);
if (utcOffset == TimeSpan.Zero)
{
_ = builder.Append('Z');
}
else
{
string sign = utcOffset < TimeSpan.Zero ? "" : "+";
_ = builder.AppendFormat(CultureInfo.InvariantCulture, "{0}{1:00}:{2:00}", sign, utcOffset.Hours, utcOffset.Minutes);
}
}
break;
}
default: // vCard 4.0
{
_ = dt.Year >= FIRST_LEAP_YEAR
? builder.AppendFormat(CultureInfo.InvariantCulture, "{0:0000}{1:00}{2:00}", dt.Year, dt.Month, dt.Day)
: builder.AppendFormat(CultureInfo.InvariantCulture, "--{0:00}{1:00}", dt.Month, dt.Day);
TimeSpan utcOffset = dt.Offset;
if (HasTimeComponent(dt))
{
_ = builder.AppendFormat(CultureInfo.InvariantCulture, "T{0:00}{1:00}{2:00}", dt.Hour, dt.Minute, dt.Second);
if (utcOffset == TimeSpan.Zero)
{
_ = builder.Append('Z');
}
else
{
string sign = utcOffset < TimeSpan.Zero ? "" : "+";
_ = builder.AppendFormat(CultureInfo.InvariantCulture, "{0}{1:00}{2:00}", sign, utcOffset.Hours, utcOffset.Minutes);
}
}
break;
}
}//switch
}
internal Name(string vCardValue, VcfDeserializationInfo info, VCdVersion version)
{
Debug.Assert(vCardValue != null);
StringBuilder builder = info.Builder;
ValueSplitter semicolonSplitter = info.SemiColonSplitter;
ValueSplitter commaSplitter = info.CommaSplitter;
semicolonSplitter.ValueString = vCardValue;
int index = 0;
foreach (var s in semicolonSplitter)
{
switch (index++)
{
case LAST_NAME:
{
if (s.Length == 0)
{
LastName = ReadOnlyCollectionConverter.Empty();
}
else
{
var list = new List <string>();
commaSplitter.ValueString = s;
foreach (var item in commaSplitter)
{
list.Add(item.UnMask(builder, version));
}
LastName = ReadOnlyCollectionConverter.ToReadOnlyCollection(list);
}
break;
}
case FIRST_NAME:
{
if (s.Length == 0)
{
FirstName = ReadOnlyCollectionConverter.Empty();
}
else
{
var list = new List <string>();
commaSplitter.ValueString = s;
foreach (var item in commaSplitter)
{
list.Add(item.UnMask(builder, version));
}
FirstName = ReadOnlyCollectionConverter.ToReadOnlyCollection(list);
}
break;
}
case MIDDLE_NAME:
{
if (s.Length == 0)
{
MiddleName = ReadOnlyCollectionConverter.Empty();
}
else
{
var list = new List <string>();
commaSplitter.ValueString = s;
foreach (var item in commaSplitter)
{
list.Add(item.UnMask(builder, version));
}
MiddleName = ReadOnlyCollectionConverter.ToReadOnlyCollection(list);
}
break;
}
case PREFIX:
{
if (s.Length == 0)
{
Prefix = ReadOnlyCollectionConverter.Empty();
}
else
{
var list = new List <string>();
commaSplitter.ValueString = s;
foreach (var item in commaSplitter)
{
list.Add(item.UnMask(builder, version));
}
Prefix = ReadOnlyCollectionConverter.ToReadOnlyCollection(list);
}
break;
}
case SUFFIX:
{
if (s.Length == 0)
{
Suffix = ReadOnlyCollectionConverter.Empty();
}
else
{
var list = new List <string>();
commaSplitter.ValueString = s;
foreach (var item in commaSplitter)
{
list.Add(item.UnMask(builder, version));
}
Suffix = ReadOnlyCollectionConverter.ToReadOnlyCollection(list);
}
break;
}
} //switch
} //foreach
// Wenn die VCF-Datei fehlerhaft ist, könnten Properties null sein:
FirstName ??= ReadOnlyCollectionConverter.Empty();
LastName ??= ReadOnlyCollectionConverter.Empty();
MiddleName ??= ReadOnlyCollectionConverter.Empty();
Prefix ??= ReadOnlyCollectionConverter.Empty();
Suffix ??= ReadOnlyCollectionConverter.Empty();
}
public static string ToVcfString(
this IEnumerable <VCard?> vCards,
VCdVersion version = VCard.DEFAULT_VERSION,
VcfOptions options = VcfOptions.Default)
=> VCard.ToVcfString(vCards, version, options: options);
internal ProfileProperty(VcfRow row, VCdVersion version) : base(row, version)
{
}
internal Address(string vCardValue, VcfDeserializationInfo info, VCdVersion version)
{
Debug.Assert(vCardValue != null);
StringBuilder builder = info.Builder;
ValueSplitter semicolonSplitter = info.SemiColonSplitter;
ValueSplitter commaSplitter = info.CommaSplitter;
int index = 0;
semicolonSplitter.ValueString = vCardValue;
foreach (var s in semicolonSplitter)
{
switch (index++)
{
#pragma warning disable CS0618 // Typ oder Element ist veraltet
case POST_OFFICE_BOX:
{
if (s.Length == 0)
{
PostOfficeBox = ReadOnlyCollectionConverter.Empty();
}
else
{
var list = new List <string>();
commaSplitter.ValueString = s;
foreach (var item in commaSplitter)
{
list.Add(item.UnMask(builder, version));
}
PostOfficeBox = ReadOnlyCollectionConverter.ToReadOnlyCollection(list);
}
break;
}
case EXTENDED_ADDRESS:
{
if (s.Length == 0)
{
ExtendedAddress = ReadOnlyCollectionConverter.Empty();
}
else
{
var list = new List <string>();
commaSplitter.ValueString = s;
foreach (var item in commaSplitter)
{
list.Add(item.UnMask(builder, version));
}
ExtendedAddress = ReadOnlyCollectionConverter.ToReadOnlyCollection(list);
}
break;
}
#pragma warning restore CS0618 // Typ oder Element ist veraltet
case STREET:
{
if (s.Length == 0)
{
Street = ReadOnlyCollectionConverter.Empty();
}
else
{
var list = new List <string>();
commaSplitter.ValueString = s;
foreach (var item in commaSplitter)
{
list.Add(item.UnMask(builder, version));
}
Street = ReadOnlyCollectionConverter.ToReadOnlyCollection(list);
}
break;
}
case LOCALITY:
{
if (s.Length == 0)
{
Locality = ReadOnlyCollectionConverter.Empty();
}
else
{
var list = new List <string>();
commaSplitter.ValueString = s;
foreach (var item in commaSplitter)
{
list.Add(item.UnMask(builder, version));
}
Locality = ReadOnlyCollectionConverter.ToReadOnlyCollection(list);
}
break;
}
case REGION:
{
if (s.Length == 0)
{
Region = ReadOnlyCollectionConverter.Empty();
}
else
{
var list = new List <string>();
commaSplitter.ValueString = s;
foreach (var item in commaSplitter)
{
list.Add(item.UnMask(builder, version));
}
Region = ReadOnlyCollectionConverter.ToReadOnlyCollection(list);
}
break;
}
case POSTAL_CODE:
{
if (s.Length == 0)
{
PostalCode = ReadOnlyCollectionConverter.Empty();
}
else
{
var list = new List <string>();
commaSplitter.ValueString = s;
foreach (var item in commaSplitter)
{
list.Add(item.UnMask(builder, version));
}
PostalCode = ReadOnlyCollectionConverter.ToReadOnlyCollection(list);
}
break;
}
case COUNTRY:
{
if (s.Length == 0)
{
Country = ReadOnlyCollectionConverter.Empty();
}
else
{
var list = new List <string>();
commaSplitter.ValueString = s;
foreach (var item in commaSplitter)
{
list.Add(item.UnMask(builder, version));
}
Country = ReadOnlyCollectionConverter.ToReadOnlyCollection(list);
}
break;
}
default:
break;
} //switch
} //foreach
// Wenn die VCF-Datei fehlerhaft ist, könnten Properties null sein:
#pragma warning disable CS0618 // Typ oder Element ist veraltet
PostOfficeBox ??= ReadOnlyCollectionConverter.Empty();
ExtendedAddress ??= ReadOnlyCollectionConverter.Empty();
#pragma warning restore CS0618 // Typ oder Element ist veraltet
Street ??= ReadOnlyCollectionConverter.Empty();
Locality ??= ReadOnlyCollectionConverter.Empty();
Region ??= ReadOnlyCollectionConverter.Empty();
PostalCode ??= ReadOnlyCollectionConverter.Empty();
Country ??= ReadOnlyCollectionConverter.Empty();
}
public void ParseTest(string?input, VCdVersion expected) => Assert.AreEqual(expected, VCdVersionConverter.Parse(input));
