BaconographyPortable.Services.Impl.SettingsServiceImpl.Initialize C# (CSharp) Method

        public async Task Initialize(IBaconProvider baconProvider)
        {
            _baconProvider = baconProvider;
            try
            {
                var offlineService = _baconProvider.GetService<IOfflineService>();

                var allowOver18String = await offlineService.GetSetting("AllowOver18");
                if (!string.IsNullOrWhiteSpace(allowOver18String))
                    AllowOver18 = bool.Parse(allowOver18String);
                else
                    AllowOver18 = false;

                var maxTopLevelOfflineCommentsString = await offlineService.GetSetting("MaxTopLevelOfflineComments");
                if (!string.IsNullOrWhiteSpace(maxTopLevelOfflineCommentsString))
                    MaxTopLevelOfflineComments = int.Parse(maxTopLevelOfflineCommentsString);
                else
                    MaxTopLevelOfflineComments = 50;

                var offlineOnlyGetsFirstSetString = await offlineService.GetSetting("OfflineOnlyGetsFirstSet");
                if (!string.IsNullOrWhiteSpace(offlineOnlyGetsFirstSetString))
                    OfflineOnlyGetsFirstSet = bool.Parse(offlineOnlyGetsFirstSetString);
                else
                    OfflineOnlyGetsFirstSet = true;

                var openLinksInBrowserString = await offlineService.GetSetting("OpenLinksInBrowser");
                if (!string.IsNullOrWhiteSpace(openLinksInBrowserString))
                    OpenLinksInBrowser = bool.Parse(openLinksInBrowserString);
                else
                    OpenLinksInBrowser = false;

                var highlightAlreadyClickedLinksString = await offlineService.GetSetting("HighlightAlreadyClickedLinks");
                if (!string.IsNullOrWhiteSpace(highlightAlreadyClickedLinksString))
                    HighlightAlreadyClickedLinks = bool.Parse(highlightAlreadyClickedLinksString);
                else
                    HighlightAlreadyClickedLinks = true;

                var applyReadabliltyToLinksString = await offlineService.GetSetting("ApplyReadabliltyToLinks");
                if (!string.IsNullOrWhiteSpace(applyReadabliltyToLinksString))
                    ApplyReadabliltyToLinks = bool.Parse(applyReadabliltyToLinksString);
                else
                    ApplyReadabliltyToLinks = false;

                var preferImageLinksForTiles = await offlineService.GetSetting("PreferImageLinksForTiles");
                if (!string.IsNullOrWhiteSpace(preferImageLinksForTiles))
                    PreferImageLinksForTiles = bool.Parse(preferImageLinksForTiles);
                else
                    PreferImageLinksForTiles = true;

                var defaultOfflineLinkCount = await offlineService.GetSetting("DefaultOfflineLinkCount");
                if (!string.IsNullOrWhiteSpace(defaultOfflineLinkCount))
                    DefaultOfflineLinkCount = int.Parse(defaultOfflineLinkCount);
                else
                    DefaultOfflineLinkCount = 25;

                var leftHandedMode = await offlineService.GetSetting("LeftHandedMode");
                if (!string.IsNullOrWhiteSpace(leftHandedMode))
                    LeftHandedMode = bool.Parse(leftHandedMode);
                else
                    LeftHandedMode = false;

                var orientationLock = await offlineService.GetSetting("OrientationLock");
                if (!string.IsNullOrWhiteSpace(orientationLock))
                    OrientationLock = bool.Parse(orientationLock);
                else
                    OrientationLock = false;

                var orientation = await offlineService.GetSetting("Orientation");
                if (!string.IsNullOrWhiteSpace(orientation))
                    Orientation = orientation;
                else
                    Orientation = "";

                var predicitveOfflining = await offlineService.GetSetting("AllowPredictiveOfflining");
                if (!string.IsNullOrWhiteSpace(predicitveOfflining))
                    AllowPredictiveOfflining = bool.Parse(predicitveOfflining);
                else
                    AllowPredictiveOfflining = false;

                PromptForCaptcha = true;
                var over18Items = await offlineService.GetSetting("AllowOver18Items");
                if (!string.IsNullOrWhiteSpace(over18Items))
                    AllowOver18Items = bool.Parse(over18Items);
                else
                    AllowOver18Items = false;

                var predictiveOffliningOnMeteredConnection = await offlineService.GetSetting("AllowPredictiveOffliningOnMeteredConnection");
                if (!string.IsNullOrWhiteSpace(predictiveOffliningOnMeteredConnection))
                    AllowPredictiveOffliningOnMeteredConnection = bool.Parse(predictiveOffliningOnMeteredConnection);
                else
                    AllowPredictiveOffliningOnMeteredConnection = false;

                var overlayOpacity = await offlineService.GetSetting("OverlayOpacity");
                if (!string.IsNullOrWhiteSpace(overlayOpacity))
                    OverlayOpacity = int.Parse(overlayOpacity);
                else
                    OverlayOpacity = 40;

                var highresLockScreenOnly = await offlineService.GetSetting("HighresLockScreenOnly");
                if (!string.IsNullOrWhiteSpace(highresLockScreenOnly))
                    HighresLockScreenOnly = bool.Parse(highresLockScreenOnly);
                else
                    HighresLockScreenOnly = false;

                var messagesInLockScreenOverlay = await offlineService.GetSetting("MessagesInLockScreenOverlay");
                if (!string.IsNullOrWhiteSpace(messagesInLockScreenOverlay))
                    MessagesInLockScreenOverlay = bool.Parse(messagesInLockScreenOverlay);
                else
                    MessagesInLockScreenOverlay = true;

                var enableUpdates = await offlineService.GetSetting("EnableUpdates");
                if (!string.IsNullOrWhiteSpace(enableUpdates))
                    EnableUpdates = bool.Parse(enableUpdates);
                else
                    EnableUpdates = true;

                var postsInLockScreenOverlay = await offlineService.GetSetting("PostsInLockScreenOverlay");
                if (!string.IsNullOrWhiteSpace(postsInLockScreenOverlay))
                    PostsInLockScreenOverlay = bool.Parse(postsInLockScreenOverlay);
                else
                    PostsInLockScreenOverlay = true;

                var imagesSubreddit = await offlineService.GetSetting("ImagesSubreddit");
                if (!string.IsNullOrWhiteSpace(imagesSubreddit))
                    ImagesSubreddit = imagesSubreddit;
                else
                    ImagesSubreddit = "/r/earthporn+InfrastructurePorn+MachinePorn";

                var lockScreenReddit = await offlineService.GetSetting("LockScreenReddit");
                if (!string.IsNullOrWhiteSpace(lockScreenReddit))
                    LockScreenReddit = lockScreenReddit;
                else
                    LockScreenReddit = "/";

                var liveTileReddit = await offlineService.GetSetting("LiveTileReddit");
                if (!string.IsNullOrWhiteSpace(liveTileReddit))
                    LiveTileReddit = liveTileReddit;
                else
                    LiveTileReddit = "/";

                var overlayItemCount = await offlineService.GetSetting("OverlayItemCount");
                if (!string.IsNullOrWhiteSpace(overlayItemCount))
                    OverlayItemCount = int.Parse(overlayItemCount);
                else
                    OverlayItemCount = 5;

                var offlineCacheDays = await offlineService.GetSetting("OfflineCacheDays");
                if (!string.IsNullOrWhiteSpace(offlineCacheDays))
                    OfflineCacheDays = int.Parse(offlineCacheDays);
                else
                    OfflineCacheDays = 2;

                var enableOvernightUpdates = await offlineService.GetSetting("EnableOvernightUpdates");
                if (!string.IsNullOrWhiteSpace(enableOvernightUpdates))
                    EnableOvernightUpdates = bool.Parse(enableOvernightUpdates);
                else
                    EnableOvernightUpdates = true;

                var updateOverlayOnlyOnWifi = await offlineService.GetSetting("UpdateOverlayOnlyOnWifi");
                if (!string.IsNullOrWhiteSpace(updateOverlayOnlyOnWifi))
                    UpdateOverlayOnlyOnWifi = bool.Parse(updateOverlayOnlyOnWifi);
                else
                    UpdateOverlayOnlyOnWifi = false;

                var updateImagesOnlyOnWifi = await offlineService.GetSetting("UpdateImagesOnlyOnWifi");
                if (!string.IsNullOrWhiteSpace(updateImagesOnlyOnWifi))
                    UpdateImagesOnlyOnWifi = bool.Parse(updateImagesOnlyOnWifi);
                else
                    UpdateImagesOnlyOnWifi = true;

                var allowAdvertising = await offlineService.GetSetting("AllowAdvertising");
                if (!string.IsNullOrWhiteSpace(allowAdvertising))
                    AllowAdvertising = bool.Parse(allowAdvertising);
                else
                    AllowAdvertising = true;

                var lastUpdatedImages = await offlineService.GetSetting("LastUpdatedImages");
                if (!string.IsNullOrWhiteSpace(lastUpdatedImages))
                    LastUpdatedImages = DateTime.Parse(lastUpdatedImages);
                else
                    LastUpdatedImages = new DateTime();

                var lastCleanedCache = await offlineService.GetSetting("LastCleanedCache");
                if (!string.IsNullOrWhiteSpace(lastCleanedCache))
                    LastCleanedCache = DateTime.Parse(lastCleanedCache);
                else
                    LastCleanedCache = new DateTime();

                var tapForComments = await offlineService.GetSetting("TapForComments");
                if (!string.IsNullOrWhiteSpace(tapForComments))
                    TapForComments = bool.Parse(tapForComments);
                else
                    TapForComments = false;

                var useImagePickerForLockScreen = await offlineService.GetSetting("UseImagePickerForLockScreen");
                if (!string.IsNullOrWhiteSpace(useImagePickerForLockScreen))
                    UseImagePickerForLockScreen = bool.Parse(useImagePickerForLockScreen);
                else
                    UseImagePickerForLockScreen = false;

                var roundedLockScreen = await offlineService.GetSetting("RoundedLockScreen");
                if (!string.IsNullOrWhiteSpace(roundedLockScreen))
                    RoundedLockScreen = bool.Parse(roundedLockScreen);
                else
                    RoundedLockScreen = false;

                var multiColoredCommentMargins = await offlineService.GetSetting("MultiColorCommentMargins");
                if (!string.IsNullOrWhiteSpace(multiColoredCommentMargins))
                    MultiColorCommentMargins = bool.Parse(multiColoredCommentMargins);
                else
                    MultiColorCommentMargins = false;

                var invertSystemTheme = await offlineService.GetSetting("InvertSystemTheme");
                if (!string.IsNullOrWhiteSpace(invertSystemTheme))
                    InvertSystemTheme = bool.Parse(invertSystemTheme);
                else
                    InvertSystemTheme = false;
                
                var onlyFlipViewUnread = await offlineService.GetSetting("OnlyFlipViewUnread");
                if (!string.IsNullOrWhiteSpace(onlyFlipViewUnread))
                    OnlyFlipViewUnread = bool.Parse(onlyFlipViewUnread);
                else
                    OnlyFlipViewUnread = false;

                var onlyFlipViewImages = await offlineService.GetSetting("OnlyFlipViewImages2");
                if (!string.IsNullOrWhiteSpace(onlyFlipViewImages))
                    OnlyFlipViewImages = bool.Parse(onlyFlipViewImages);
                else
                    OnlyFlipViewImages = true;

                Messenger.Default.Send<SettingsChangedMessage>(new SettingsChangedMessage { InitialLoad = true });
            }
            catch
            {
                //not interested in failure here
            }
        }