internal BodyTextReader(ICoreItem coreItem, BodyReadConfiguration configuration, Stream inputStream)
{
using (DisposeGuard disposeGuard = this.Guard())
{
Stream stream = null;
TextReader textReader = null;
bool flag = false;
this.disposeTracker = this.GetDisposeTracker();
try
{
if (inputStream == null)
{
stream = BodyReadStream.OpenBodyStream(coreItem);
inputStream = stream;
}
if (inputStream == null)
{
inputStream = Body.GetEmptyStream();
}
textReader = BodyReadDelegates.CreateReader(coreItem, configuration, inputStream, out this.conversionCallbacks);
flag = true;
}
finally
{
if (!flag && stream != null)
{
stream.Dispose();
}
}
this.reader = textReader;
this.bodyStream = stream;
this.isDisposed = false;
disposeGuard.Success();
}
}
private static object FromRtfToHtml(ICoreItem coreItem, BodyReadConfiguration configuration, Stream bodyStream, bool createReader)
{
object obj = null;
Stream stream = null;
try
{
stream = new ConverterStream(bodyStream, new RtfCompressedToRtf(), ConverterStreamAccess.Read);
RtfToHtml rtfToHtml = new RtfToHtml();
rtfToHtml.OutputEncoding = configuration.Encoding;
rtfToHtml.Header = configuration.InjectPrefix;
rtfToHtml.Footer = configuration.InjectSuffix;
rtfToHtml.HeaderFooterFormat = configuration.InjectionHeaderFooterFormat;
rtfToHtml.FilterHtml = configuration.FilterHtml;
rtfToHtml.HtmlTagCallback = configuration.InternalHtmlTagCallback;
rtfToHtml.OutputHtmlFragment = configuration.IsHtmlFragment;
if (configuration.StyleSheetLimit != null)
{
TextConvertersInternalHelpers.SetSmallCssBlockThreshold(rtfToHtml, configuration.StyleSheetLimit.Value);
}
obj = BodyReadDelegates.GetTextStreamOrReader(stream, rtfToHtml, createReader);
}
finally
{
if (obj == null && stream != null)
{
stream.Dispose();
stream = null;
}
}
return(obj);
}
private char[] LoadCachedBodyData(out MemoryStream htmlBody)
{
htmlBody = null;
if (!this.coreItem.Body.IsBodyDefined)
{
return(null);
}
BodyReadConfiguration configuration = new BodyReadConfiguration(BodyFormat.TextPlain);
if (this.coreItem.Body.RawFormat == BodyFormat.TextHtml)
{
htmlBody = this.LoadHtmlBodyInMemory();
htmlBody.Position = 0L;
using (TextReader textReader = new BodyTextReader(this.coreItem, configuration, new StreamWrapper(htmlBody, false)))
{
return(Util.StreamHandler.ReadCharBuffer(textReader, 16384));
}
}
char[] result;
using (TextReader textReader2 = new BodyTextReader(this.coreItem, configuration, null))
{
result = Util.StreamHandler.ReadCharBuffer(textReader2, 16384);
}
return(result);
}
private static object FromRtfToRtf(ICoreItem coreItem, BodyReadConfiguration configuration, Stream bodyStream, bool createReader)
{
object obj = null;
Stream stream = null;
try
{
stream = new ConverterStream(bodyStream, new RtfCompressedToRtf(), ConverterStreamAccess.Read);
obj = BodyReadDelegates.GetRtfStreamOrReader(stream, new RtfToRtf
{
Header = configuration.InjectPrefix,
Footer = configuration.InjectSuffix,
HeaderFooterFormat = configuration.InjectionHeaderFooterFormat
}, createReader);
}
finally
{
if (obj == null && stream != null)
{
stream.Dispose();
stream = null;
}
}
return(obj);
}
internal static void CopyBodyWithPrefix(Body sourceBody, Body targetBody, ReplyForwardConfiguration configuration, BodyConversionCallbacks callbacks)
{
ReplyForwardCommon.CheckRtf(sourceBody.RawFormat, targetBody.RawFormat);
BodyReadConfiguration configuration2 = new BodyReadConfiguration(sourceBody.RawFormat, sourceBody.RawCharset.Name);
BodyWriteConfiguration bodyWriteConfiguration = new BodyWriteConfiguration(sourceBody.RawFormat, sourceBody.RawCharset.Name);
bodyWriteConfiguration.SetTargetFormat(configuration.TargetFormat, sourceBody.Charset);
if (!string.IsNullOrEmpty(configuration.BodyPrefix))
{
bodyWriteConfiguration.AddInjectedText(configuration.BodyPrefix, null, configuration.BodyPrefixFormat);
}
if (callbacks.HtmlCallback != null || callbacks.RtfCallback != null)
{
bodyWriteConfiguration.HtmlCallback = callbacks.HtmlCallback;
bodyWriteConfiguration.RtfCallback = callbacks.RtfCallback;
if (!configuration.ShouldSkipFilterHtmlOnBodyWrite)
{
bodyWriteConfiguration.HtmlFlags = HtmlStreamingFlags.FilterHtml;
}
}
using (Stream stream = sourceBody.OpenReadStream(configuration2))
{
using (Stream stream2 = targetBody.OpenWriteStream(bodyWriteConfiguration))
{
Util.StreamHandler.CopyStreamData(stream, stream2);
}
}
}
public byte[] GetPartialRtfCompressedBody(int nBytes)
{
BodyReadConfiguration configuration = new BodyReadConfiguration(BodyFormat.ApplicationRtf);
byte[] result;
using (Stream stream = this.OpenReadStream(configuration))
{
byte[] array = new byte[nBytes];
int num;
int num2;
for (num = 0; num != nBytes; num += num2)
{
num2 = stream.Read(array, num, nBytes - num);
if (num2 == 0)
{
break;
}
}
if (num == nBytes)
{
result = array;
}
else
{
byte[] array2 = new byte[num];
Array.Copy(array, array2, num);
result = array2;
}
}
return(result);
}
private static void InternalCopyBody(Body source, Body target, CultureInfo cultureInfo, bool removeMungageData, string prefix, BodyInjectionFormat prefixFormat, bool disableCharsetDetection = false)
{
BodyReadConfiguration bodyReadConfiguration = new BodyReadConfiguration(source.RawFormat, source.RawCharset.Name);
BodyWriteConfiguration bodyWriteConfiguration = new BodyWriteConfiguration(source.RawFormat, source.RawCharset.Name);
if (disableCharsetDetection)
{
bodyWriteConfiguration.SetTargetFormat(source.RawFormat, source.Charset, BodyCharsetFlags.DisableCharsetDetection);
}
else
{
bodyWriteConfiguration.SetTargetFormat(source.RawFormat, source.Charset);
}
if (!string.IsNullOrEmpty(prefix))
{
bodyWriteConfiguration.AddInjectedText(prefix, null, prefixFormat);
}
bool flag = false;
if (removeMungageData)
{
flag = Body.CopyBodyWithoutMungage(source, target, cultureInfo, bodyReadConfiguration, bodyWriteConfiguration);
}
if (!flag)
{
using (Stream stream = source.OpenReadStream(bodyReadConfiguration))
{
using (Stream stream2 = target.OpenWriteStream(bodyWriteConfiguration))
{
Util.StreamHandler.CopyStreamData(stream, stream2, null, 0, 16384);
}
}
}
}
private void BuildMeetingMessageBody(BodyConversionCallbacks callbacks)
{
BodyReadConfiguration configuration = new BodyReadConfiguration(this.originalItem.Body.RawFormat);
BodyWriteConfiguration bodyWriteConfiguration = new BodyWriteConfiguration(this.originalItem.Body.RawFormat);
bodyWriteConfiguration.SetTargetFormat(this.parameters.TargetFormat, this.originalItem.Body.Charset);
if (!string.IsNullOrEmpty(this.parameters.BodyPrefix))
{
bodyWriteConfiguration.AddInjectedText(this.parameters.BodyPrefix, null, this.parameters.BodyPrefixFormat);
}
if (callbacks.HtmlCallback != null)
{
bodyWriteConfiguration.HtmlCallback = callbacks.HtmlCallback;
bodyWriteConfiguration.HtmlFlags = HtmlStreamingFlags.FilterHtml;
}
if (callbacks.RtfCallback != null)
{
bodyWriteConfiguration.RtfCallback = callbacks.RtfCallback;
}
using (TextReader textReader = this.originalItem.Body.OpenTextReader(configuration))
{
using (TextWriter textWriter = this.newItem.Body.OpenTextWriter(bodyWriteConfiguration))
{
Util.StreamHandler.CopyText(textReader, textWriter);
}
}
}
private static object FromTextToRtf(ICoreItem coreItem, BodyReadConfiguration configuration, Stream bodyStream, bool createReader)
{
return(BodyReadDelegates.GetRtfStreamOrReader(bodyStream, new TextToRtf
{
InputEncoding = ConvertUtils.UnicodeEncoding,
Header = configuration.InjectPrefix,
Footer = configuration.InjectSuffix,
HeaderFooterFormat = configuration.InjectionHeaderFooterFormat
}, createReader));
}
internal static TextReader CreateReader(ICoreItem coreItem, BodyReadConfiguration configuration, Stream bodyStream, out ConversionCallbackBase provider)
{
BodyReadConfiguration readerConfiguration = new BodyReadConfiguration(configuration);
readerConfiguration.Charset = ConvertUtils.UnicodeCharset;
provider = BodyReadDelegates.CreateConversionDelegateProvider(coreItem, readerConfiguration);
return(ConvertUtils.CallCtsWithReturnValue <TextReader>(ExTraceGlobals.CcBodyTracer, "BodyReadDelegates::CreateReader", ServerStrings.ConversionBodyConversionFailed, delegate
{
BodyReadDelegates.ConversionCreator conversionMethod = BodyReadDelegates.GetConversionMethod(coreItem, configuration);
return (TextReader)conversionMethod(coreItem, readerConfiguration, bodyStream, true);
}));
}
internal static BodyReadStream TryCreateBodyReadStream(ICoreItem coreItem, BodyReadConfiguration configuration, bool createEmtpyStreamIfNotFound)
{
BodyReadStream bodyReadStream = BodyReadStream.InternalTryCreateBodyStream(coreItem, configuration, createEmtpyStreamIfNotFound, null);
if (configuration.ShouldCalculateLength)
{
long streamLength = BodyReadStream.GetStreamLength(bodyReadStream);
bodyReadStream.Dispose();
bodyReadStream = BodyReadStream.InternalTryCreateBodyStream(coreItem, configuration, createEmtpyStreamIfNotFound, new long?(streamLength));
}
return(bodyReadStream);
}
public override void Export(ContactWriter writer, Contact contact, OutboundVCardConverter.PropertyExporter.Context context)
{
if (contact.Body.IsBodyDefined)
{
BodyReadConfiguration configuration = new BodyReadConfiguration(BodyFormat.TextPlain, context.Encoding.WebName);
using (Stream stream = contact.Body.OpenReadStream(configuration))
{
writer.StartProperty(PropertyId.Note);
writer.WritePropertyValue(stream);
}
}
}
public string GetPartialTextBody(int length)
{
BodyReadConfiguration configuration = new BodyReadConfiguration(BodyFormat.TextPlain);
string result;
using (TextReader textReader = this.OpenTextReader(configuration))
{
char[] array = new char[length];
int length2 = Body.ReadChars(textReader, array, length);
result = new string(array, 0, length2);
}
return(result);
}
protected override void BuildBody(BodyConversionCallbacks callbacks)
{
BodyReadConfiguration configuration = new BodyReadConfiguration(this.template.Body.RawFormat, this.template.Body.RawCharset.Name);
BodyWriteConfiguration bodyWriteConfiguration = new BodyWriteConfiguration(this.template.Body.RawFormat, this.template.Body.RawCharset.Name);
bodyWriteConfiguration.SetTargetFormat(this.template.Body.Format, this.template.Body.Charset);
using (Stream stream = this.template.Body.OpenReadStream(configuration))
{
using (Stream stream2 = this.newItem.Body.OpenWriteStream(bodyWriteConfiguration))
{
Util.StreamHandler.CopyStreamData(stream, stream2);
}
}
}
private static object FromTextToHtml(ICoreItem coreItem, BodyReadConfiguration configuration, Stream bodyStream, bool createReader)
{
return(BodyReadDelegates.GetTextStreamOrReader(bodyStream, new TextToHtml
{
InputEncoding = ConvertUtils.UnicodeEncoding,
OutputEncoding = configuration.Encoding,
Header = configuration.InjectPrefix,
Footer = configuration.InjectSuffix,
HeaderFooterFormat = configuration.InjectionHeaderFooterFormat,
HtmlTagCallback = configuration.InternalHtmlTagCallback,
FilterHtml = configuration.FilterHtml,
OutputHtmlFragment = configuration.IsHtmlFragment
}, createReader));
}
private Stream InternalOpenReadStream(BodyReadConfiguration configuration, bool createEmptyStreamIfNotFound)
{
Body.CheckNull(configuration, "configuration");
this.CheckStreamingExceptions();
Stream result;
lock (this.bodyStreamsLock)
{
this.CheckOpenBodyStreamForRead();
BodyReadStream bodyReadStream = BodyReadStream.TryCreateBodyReadStream(this.coreItem, configuration, createEmptyStreamIfNotFound);
this.bodyReadStreams.Add(bodyReadStream);
result = bodyReadStream;
}
return(result);
}
public string GetPartialHtmlBody(int length, HtmlCallbackBase htmlCallbacks, bool filterHtml, int styleSheetLimit)
{
BodyReadConfiguration bodyReadConfiguration = new BodyReadConfiguration(BodyFormat.TextHtml);
bodyReadConfiguration.SetHtmlOptions(filterHtml ? HtmlStreamingFlags.FilterHtml : HtmlStreamingFlags.None, htmlCallbacks, new int?(styleSheetLimit));
string result;
using (TextReader textReader = this.OpenTextReader(bodyReadConfiguration))
{
char[] array = new char[length];
int length2 = Body.ReadChars(textReader, array, length);
result = new string(array, 0, length2);
}
return(result);
}
internal ConversationBodyTextReader OpenConversationTextReader(BodyReadConfiguration configuration, long bytesLoadedForConversation, long maxBytesForConversation)
{
Body.CheckNull(configuration, "configuration");
this.CheckStreamingExceptions();
ConversationBodyTextReader result;
lock (this.bodyStreamsLock)
{
this.CheckOpenBodyStreamForRead();
ConversationBodyTextReader conversationBodyTextReader = new ConversationBodyTextReader(this.coreItem, configuration, null, bytesLoadedForConversation, maxBytesForConversation);
this.bodyReadStreams.Add(conversationBodyTextReader);
result = conversationBodyTextReader;
}
return(result);
}
private static object FromHtmlToRtf(ICoreItem coreItem, BodyReadConfiguration configuration, Stream bodyStream, bool createReader)
{
HtmlToRtf htmlToRtf = new HtmlToRtf();
htmlToRtf.InputEncoding = ConvertUtils.GetItemMimeCharset(coreItem.PropertyBag).GetEncoding();
htmlToRtf.DetectEncodingFromMetaTag = false;
htmlToRtf.Header = configuration.InjectPrefix;
htmlToRtf.Footer = configuration.InjectSuffix;
htmlToRtf.HeaderFooterFormat = configuration.InjectionHeaderFooterFormat;
if (configuration.ImageRenderingCallback != null)
{
TextConvertersInternalHelpers.SetImageRenderingCallback(htmlToRtf, configuration.ImageRenderingCallback);
}
return(BodyReadDelegates.GetRtfStreamOrReader(bodyStream, htmlToRtf, createReader));
}
public TextReader OpenTextReader(BodyReadConfiguration configuration)
{
Body.CheckNull(configuration, "configuration");
this.CheckStreamingExceptions();
TextReader result;
lock (this.bodyStreamsLock)
{
this.CheckOpenBodyStreamForRead();
BodyTextReader bodyTextReader = new BodyTextReader(this.coreItem, configuration, null);
this.bodyReadStreams.Add(bodyTextReader);
result = bodyTextReader;
}
return(result);
}
internal BodyReadConfiguration(BodyReadConfiguration configuration)
{
this.format = configuration.format;
this.charset = configuration.charset;
this.injectPrefix = configuration.injectPrefix;
this.injectSuffix = configuration.injectSuffix;
this.injectFormat = configuration.injectFormat;
this.conversionCallback = configuration.conversionCallback;
this.htmlFlags = configuration.htmlFlags;
this.styleSheetLimit = configuration.styleSheetLimit;
this.shouldCalculateLength = configuration.shouldCalculateLength;
this.ShouldUseNarrowGapForPTagHtmlToTextConversion = configuration.ShouldUseNarrowGapForPTagHtmlToTextConversion;
this.ShouldOutputAnchorLinks = configuration.ShouldOutputAnchorLinks;
this.ShouldOutputImageLinks = configuration.ShouldOutputImageLinks;
}
private void AddBodyPrefix(string prefix)
{
byte[] array = null;
BodyReadConfiguration configuration = new BodyReadConfiguration(base.Body.RawFormat, base.Body.RawCharset.Name);
using (Stream stream = base.Body.OpenReadStream(configuration))
{
array = Util.StreamHandler.ReadBytesFromStream(stream);
}
BodyWriteConfiguration bodyWriteConfiguration = new BodyWriteConfiguration(base.Body.RawFormat, base.Body.RawCharset.Name);
bodyWriteConfiguration.SetTargetFormat(base.Body.Format, base.Body.Charset);
bodyWriteConfiguration.AddInjectedText(prefix, null, BodyInjectionFormat.Text);
using (Stream stream2 = base.Body.OpenWriteStream(bodyWriteConfiguration))
{
stream2.Write(array, 0, array.Length);
}
}
private static object FromHtmlToText(ICoreItem coreItem, BodyReadConfiguration configuration, Stream bodyStream, bool createReader)
{
HtmlToText htmlToText = new HtmlToText();
htmlToText.InputEncoding = ConvertUtils.GetItemMimeCharset(coreItem.PropertyBag).GetEncoding();
htmlToText.OutputEncoding = configuration.Encoding;
htmlToText.DetectEncodingFromMetaTag = false;
htmlToText.Header = configuration.InjectPrefix;
htmlToText.Footer = configuration.InjectSuffix;
htmlToText.HeaderFooterFormat = configuration.InjectionHeaderFooterFormat;
htmlToText.ShouldUseNarrowGapForPTagHtmlToTextConversion = configuration.ShouldUseNarrowGapForPTagHtmlToTextConversion;
htmlToText.OutputAnchorLinks = configuration.ShouldOutputAnchorLinks;
htmlToText.OutputImageLinks = configuration.ShouldOutputImageLinks;
if (configuration.ImageRenderingCallback != null)
{
TextConvertersInternalHelpers.SetImageRenderingCallback(htmlToText, configuration.ImageRenderingCallback);
}
return(BodyReadDelegates.GetTextStreamOrReader(bodyStream, htmlToText, createReader));
}
internal static Stream CreateStream(ICoreItem coreItem, BodyReadConfiguration configuration, Stream bodyStream, out ConversionCallbackBase provider)
{
BodyReadConfiguration readConfiguration = new BodyReadConfiguration(configuration);
provider = BodyReadDelegates.CreateConversionDelegateProvider(coreItem, readConfiguration);
if (readConfiguration.Charset == null)
{
readConfiguration.Charset = ConvertUtils.GetItemMimeCharset(coreItem.PropertyBag);
}
if (!readConfiguration.IsBodyTransformationNeeded(coreItem.Body))
{
return(bodyStream);
}
return(ConvertUtils.CallCtsWithReturnValue <Stream>(ExTraceGlobals.CcBodyTracer, "BodyReadDelegates::CreateStream", ServerStrings.ConversionBodyConversionFailed, delegate
{
BodyReadDelegates.ConversionCreator conversionMethod = BodyReadDelegates.GetConversionMethod(coreItem, configuration);
return (Stream)conversionMethod(coreItem, readConfiguration, bodyStream, false);
}));
}
private static object FromHtmlToHtml(ICoreItem coreItem, BodyReadConfiguration configuration, Stream bodyStream, bool createReader)
{
Charset itemMimeCharset = ConvertUtils.GetItemMimeCharset(coreItem.PropertyBag);
Charset charset = configuration.Charset;
HtmlToHtml htmlToHtml = new HtmlToHtml();
htmlToHtml.InputEncoding = itemMimeCharset.GetEncoding();
htmlToHtml.OutputEncoding = charset.GetEncoding();
htmlToHtml.Header = configuration.InjectPrefix;
htmlToHtml.Footer = configuration.InjectSuffix;
htmlToHtml.HeaderFooterFormat = configuration.InjectionHeaderFooterFormat;
htmlToHtml.DetectEncodingFromMetaTag = false;
htmlToHtml.FilterHtml = configuration.FilterHtml;
htmlToHtml.HtmlTagCallback = configuration.InternalHtmlTagCallback;
htmlToHtml.OutputHtmlFragment = configuration.IsHtmlFragment;
if (configuration.StyleSheetLimit != null)
{
TextConvertersInternalHelpers.SetSmallCssBlockThreshold(htmlToHtml, configuration.StyleSheetLimit.Value);
}
return(BodyReadDelegates.GetTextStreamOrReader(bodyStream, htmlToHtml, createReader));
}
private static object FromTextToText(ICoreItem coreItem, BodyReadConfiguration configuration, Stream bodyStream, bool createReader)
{
TextToText textToText;
if (string.IsNullOrEmpty(configuration.InjectPrefix) && string.IsNullOrEmpty(configuration.InjectSuffix))
{
textToText = new TextToText(TextToTextConversionMode.ConvertCodePageOnly);
}
else
{
textToText = new TextToText();
}
textToText.InputEncoding = ConvertUtils.UnicodeEncoding;
textToText.OutputEncoding = configuration.Encoding;
if (!string.IsNullOrEmpty(configuration.InjectPrefix) || !string.IsNullOrEmpty(configuration.InjectSuffix))
{
textToText.Header = configuration.InjectPrefix;
textToText.Footer = configuration.InjectSuffix;
textToText.HeaderFooterFormat = configuration.InjectionHeaderFooterFormat;
}
return(BodyReadDelegates.GetTextStreamOrReader(bodyStream, textToText, createReader));
}
private void WriteMessageBody()
{
if (this.options.FilterBodyHandler != null && !this.options.FilterBodyHandler(this.item))
{
return;
}
this.limitsTracker.CountMessageBody();
BodyFormat rawFormat = this.item.Body.RawFormat;
if (rawFormat == BodyFormat.TextHtml)
{
this.WriteProperty(InternalSchema.HtmlBody, this.item.PropertyBag);
return;
}
this.WriteProperty(InternalSchema.RtfSyncBodyCrc, this.item.PropertyBag);
this.WriteProperty(InternalSchema.RtfSyncBodyCount, this.item.PropertyBag);
this.WriteProperty(InternalSchema.RtfSyncBodyTag, this.item.PropertyBag);
this.WriteProperty(InternalSchema.RtfInSync, this.item.PropertyBag);
this.WriteProperty(InternalSchema.RtfSyncPrefixCount, this.item.PropertyBag);
this.WriteProperty(InternalSchema.RtfSyncTrailingCount, this.item.PropertyBag);
if (!this.item.Body.IsBodyDefined)
{
return;
}
if (rawFormat == BodyFormat.TextPlain)
{
this.WriteProperty(InternalSchema.TextBody, this.item.PropertyBag);
}
BodyReadConfiguration configuration = new BodyReadConfiguration(BodyFormat.ApplicationRtf);
using (Stream stream = this.item.Body.OpenReadStream(configuration))
{
using (Stream stream2 = this.PropertyWriter.OpenPropertyStream(TnefPropertyTag.RtfCompressed))
{
Util.StreamHandler.CopyStreamData(stream, stream2);
}
}
}
private static bool CopyBodyWithoutMungage(Body source, Body target, CultureInfo cultureInfo, BodyReadConfiguration readConfiguration, BodyWriteConfiguration writeConfiguration)
{
bool result = false;
switch (source.RawFormat)
{
case BodyFormat.TextPlain:
{
bool flag = true;
goto IL_2B;
}
case BodyFormat.ApplicationRtf:
{
bool flag = false;
goto IL_2B;
}
}
return(false);
IL_2B:
using (Stream stream = source.OpenReadStream(readConfiguration))
{
Stream stream2 = null;
try
{
bool flag;
stream2 = (flag ? stream : new ConverterStream(stream, new RtfCompressedToRtf(), ConverterStreamAccess.Read));
byte[] array = new byte[16384];
int num = stream2.Read(array, 0, array.Length);
if (num > 0)
{
string @string = readConfiguration.Encoding.GetString(array, 0, num);
string pattern = string.Format("{0}[\\s\\S]+(^.*{1}[\\s\\S]+)?^.*\\*~\\*~\\*~\\*~\\*~\\*~\\*~\\*~\\*~\\*(\\\\line)?\\r\\n", Regex.Escape(ClientStrings.WhenPart.ToString(cultureInfo)), Regex.Escape(ClientStrings.WherePart.ToString(cultureInfo)));
Match match = Regex.Match(@string, pattern, RegexOptions.Multiline);
if (match.Success)
{
string s = @string.Remove(match.Index, match.Length);
byte[] bytes = writeConfiguration.SourceEncoding.GetBytes(s);
using (Stream stream3 = target.OpenWriteStream(writeConfiguration))
{
Stream stream4 = null;
try
{
stream4 = (flag ? stream3 : new ConverterStream(stream3, new RtfToRtfCompressed(), ConverterStreamAccess.Write));
stream4.Write(bytes, 0, bytes.Length);
if (num == array.Length)
{
Util.StreamHandler.CopyStreamData(stream2, stream4, null, 0, 16384);
}
result = true;
}
finally
{
if (!flag && stream4 != null)
{
stream4.Dispose();
}
}
}
}
}
}
finally
{
bool flag;
if (!flag && stream2 != null)
{
stream2.Dispose();
}
}
}
return(result);
}
internal Stream TryOpenReadStream(BodyReadConfiguration configuration)
{
return(this.InternalOpenReadStream(configuration, false));
}
public TextReader OpenTextReader(BodyFormat bodyFormat)
{
BodyReadConfiguration configuration = new BodyReadConfiguration(bodyFormat);
return(this.OpenTextReader(configuration));
}
